{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Double DQN (DDQN) variant  implementation (PyTorch).\n",
    "\n",
    "In this notebook, we will implement Double DQN (DDQN) variant of DQN carrying on from `listing6_1_dqn_pytorch.ipynb`. \n",
    "\n",
    "\n",
    "### Recap\n",
    "\n",
    "Q Learning control is carried out by sampling step by step and updating Q values at each step. We use ε-greedy policy to explore and generate samples. However, the policy learnt is a deterministic greedy policy with no exploration. We can carryout updates online i.e. we take a step and use `(current state, action, reward and next_state)` tuple to update. \n",
    "\n",
    "In case of function approximation using neural network, the input to the network is the state and output is the q(s,a) for all the actions in the state `s`. It is denoted as $ \\hat{q}(s_t,a; w_{t}) $, where $w_{t}$ is the weights of the neural network which we are trying to learn as part of DQN learning. \n",
    "\n",
    "We use two networks, one target network to get the max q-value of next state denoted by $ \\max_a \\hat {q}(s_{t+1},a; w^{-}_{t}) $ and the primary network (online network) with weights $w_{t}$ which we are updated based on back propagation of the TD error through the network.\n",
    "\n",
    "The Update equation is given below. This is the online version:\n",
    "$$ w_{t+1} \\leftarrow w_t + \\alpha [ R_{t+1} + \\gamma . \\max_{a} \\hat{q}(S_{t+1},a,w^{-}_{t}) – \\hat{q}(S_t,A_t,w_t)] \\nabla \\hat{q}(S_t,A_t,w_t)$$\n",
    "\n",
    "Online update with neural network with millions of weights does not work well. Accordingly, We use experience replay (aka Replay Buffer).  We use a behavior policy to explore the environment and store the samples `(s, a, r, s', done)` in a buffer. The samples are generated using an exploratory behavior policy while we improve a deterministic target policy using q-values. \n",
    "\n",
    "Therefore, we can always use older samples from behavior policy and apply them again and again. We can keep the buffer size fixed to some pre-determined size and keep deleting the older samples as we collect new ones. This process makes learning sample efficient by reusing a sample multiple times and also removing temporal dependence of the samples we would otherwise see while following a trajectory.\n",
    "\n",
    "The update equation with batch update with minor modifications is given below. We collect samples of transitions (current state, action, reward, next state) in a buffer. Where each sample is denoted as a tuple: \n",
    "\n",
    "$$ (s_{i}, a_{i}, r_{i}, s^{'}_{i}, done_{i})$$\n",
    "\n",
    "Subscript (i) denotes ith sample. We take N samples from experience replay selecting randomly and update the weights. Subscript (t) denotes the index of weight updates. If the current state is done, as denoted by `done` flag, the target is just the reward as terminal states have zero value. The final update equation is as given below:\n",
    "\n",
    "$$w_{t+1} \\leftarrow w_t + \\alpha \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a^{'}} \\hat{q}(s_{i}^{'},a^{'};w^{-}_{t}) \\right) – \\hat{q}(s_i,a_i;w_t) \\right] \\nabla \\hat{q}(s_i,a_i;w_t)$$\n",
    "\n",
    "\n",
    "### DDQN Double DQN\n",
    "\n",
    "In DQN (refer equation at the top of this notebook), the target value for $\\hat{q}(s_i,a_i;w_t)$ was given by:\n",
    "\n",
    "$$ \\DeclareMathOperator*{\\max}{max} Y_{i}^{DQN} =   r_i + \\left( (1-done_i) . \\gamma .  \\max_{a^{'}} \\hat{q}(s_{i}^{'},a^{'};w^{-}_{t}) \\right) $$\n",
    "\n",
    "A target network with weights $w^{-}$ was used to find the maximum q-estimate at next state $S_{t+1}$ and the weights of the target network are updated periodically from the agent network (aka online network) with weights $w$ which are being learnt.\n",
    "\n",
    "In Double DQN (DDQN), as proposed in  https://arxiv.org/pdf/1509.06461.pdf , analogous to Double Q-Learning (or DQN specifically), we again use two networks but the target value for $\\hat{q}(s_i,a_i;w_t)$ is now computed in following way:\n",
    "\n",
    "$$ \\DeclareMathOperator*{\\argmax}{argmax} Y_{i}^{DDQN} =  r_i + \\left( (1-done_i) . \\gamma .  \\hat{q}(s_{i}^{'},\\argmax_{a^{'}} \\hat{q}(s_{i}^{'}, a^{'};w_{t});w^{-}_{t})  \\right) $$\n",
    "\n",
    "When updating the weight of network with weight $w$, we use the same network to get the $argmax$ of action for state $s^{'}_{i}$, but the actual value of $$\\hat{q}$$ is calculated by using the above $argmax$ action from another network with weight $w^{-}_{t}$. Like before, we periodically update target network weights $w^{-}_{t}$ from agent/online network weight $w_{t}$ \n",
    "\n",
    "Given below is the implementation for modified `compute_td_loss` function. Rest of the code remains same. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "\n",
    "import gym\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.signal import convolve, gaussian\n",
    "import math\n",
    "import os\n",
    "import io\n",
    "import base64\n",
    "import time\n",
    "from tqdm import trange\n",
    "import glob\n",
    "import random\n",
    "from collections import namedtuple\n",
    "\n",
    "from IPython.display import HTML, clear_output\n",
    "\n",
    "%matplotlib inline\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Environment - CartPole \n",
    "\n",
    "We can use the setup here to run on any environment which has state as a single vector and actions are discrete. We will build it on Cart Pole and they try to run this on many other environments like Lunar Lander and others.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_env(env_name, seed=None):\n",
    "    # remove time limit wrapper from environment\n",
    "    env = gym.make(env_name).unwrapped\n",
    "    if seed is not None:\n",
    "        env.seed(seed)\n",
    "    return env"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ENV_NAME = 'CartPole-v1'\n",
    "\n",
    "env = make_env(ENV_NAME)\n",
    "env.reset()\n",
    "plt.imshow(env.render(\"rgb_array\"))\n",
    "state_shape, n_actions = env.observation_space.shape, env.action_space.n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building a network using pytorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us build a DQN agent using a simple network, We now need to build a neural network that can map states/observations to state q-values. The observation space and action space is as given below for CartPole\n",
    "\n",
    "    Observation:\n",
    "        Type: Box(4)\n",
    "        Num     Observation               Min                     Max\n",
    "        0       Cart Position             -4.8                    4.8\n",
    "        1       Cart Velocity             -Inf                    Inf\n",
    "        2       Pole Angle                -0.418 rad (-24 deg)    0.418 rad (24 deg)\n",
    "        3       Pole Angular Velocity     -Inf                    Inf\n",
    "    Actions:\n",
    "        Type: Discrete(2)\n",
    "        Num   Action\n",
    "        0     Push cart to the left\n",
    "        1     Push cart to the right\n",
    "        \n",
    "\n",
    "The model will be a simple one with 2 hidden payers with Relu activation and final layer being logits with dimension equation to number of actions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cpu')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent(nn.Module):\n",
    "    def __init__(self, state_shape, n_actions, epsilon=0):\n",
    "\n",
    "        super().__init__()\n",
    "        self.epsilon = epsilon\n",
    "        self.n_actions = n_actions\n",
    "        self.state_shape = state_shape\n",
    "        \n",
    "        state_dim = state_shape[0]\n",
    "        # a simple NN with state_dim as input vector (inout is state s)\n",
    "        # and self.n_actions as output vector of logits of q(s, a)\n",
    "        self.fc1 = nn.Linear(state_dim, 64)\n",
    "        self.fc2 = nn.Linear(64, 128)\n",
    "        self.fc3 = nn.Linear(128, 32)\n",
    "        self.q = nn.Linear(32, n_actions)\n",
    "        \n",
    "    def forward(self, state_t):\n",
    "        # pass the state at time t through the newrok to get Q(s,a)\n",
    "        x = F.relu(self.fc1(state_t))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = F.relu(self.fc3(x))\n",
    "        qvalues = self.q(x)\n",
    "        return qvalues\n",
    "\n",
    "    def get_qvalues(self, states):\n",
    "        # input is an array of states in numpy and outout is Qvals as numpy array\n",
    "        states = torch.tensor(states, device=device, dtype=torch.float32)\n",
    "        qvalues = self.forward(states)\n",
    "        return qvalues.data.cpu().numpy()\n",
    "\n",
    "    def sample_actions(self, qvalues):\n",
    "        # sample actions from a batch of q_values using epsilon greedy policy\n",
    "        epsilon = self.epsilon\n",
    "        batch_size, n_actions = qvalues.shape\n",
    "        random_actions = np.random.choice(n_actions, size=batch_size)\n",
    "        best_actions = qvalues.argmax(axis=-1)\n",
    "        should_explore = np.random.choice(\n",
    "            [0, 1], batch_size, p=[1-epsilon, epsilon])\n",
    "        return np.where(should_explore, random_actions, best_actions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent = DQNAgent(state_shape, n_actions, epsilon=0.5).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(env, agent, n_games=1, greedy=False, t_max=10000):\n",
    "    rewards = []\n",
    "    for _ in range(n_games):\n",
    "        s = env.reset()\n",
    "        reward = 0\n",
    "        for _ in range(t_max):\n",
    "            qvalues = agent.get_qvalues([s])\n",
    "            action = qvalues.argmax(axis=-1)[0] if greedy else agent.sample_actions(qvalues)[0]\n",
    "            s, r, done, _ = env.step(action)\n",
    "            reward += r\n",
    "            if done:\n",
    "                break\n",
    "\n",
    "        rewards.append(reward)\n",
    "    return np.mean(rewards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14.0\n"
     ]
    }
   ],
   "source": [
    "print(evaluate(env, agent, n_games=1))\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Experience replay\n",
    "\n",
    "We will use the replay buffer we saw in chapter 4 listings. Replay buffer is very important in DQN to break the correlation between samples. We use a behavior policy (epsilon greedy) to sample from the environment and store the transitions (s,a,r,s',done) into a buffer. These samples are used multiple times in a learning making the process sample efficient. \n",
    "\n",
    "The interface to ReplayBuffer is:\n",
    "* `exp_replay.add(state, action, reward, next_state, done)` - saves (s,a,r,s',done) tuple into the buffer\n",
    "* `exp_replay.sample(batch_size)` - returns states, actions, rewards, next_states and done_flags for `batch_size` random samples.\n",
    "* `len(exp_replay)` - returns number of elements stored in replay buffer.\n",
    "\n",
    "We have modified the implementation a bit to make it more efficient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    def __init__(self, size):\n",
    "        self.size = size #max number of items in buffer\n",
    "        self.buffer =[] #array to holde buffer\n",
    "        self.next_id = 0\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.buffer)\n",
    "    \n",
    "    def add(self, state, action, reward, next_state, done):\n",
    "        item = (state, action, reward, next_state, done)\n",
    "        if len(self.buffer) < self.size:\n",
    "           self.buffer.append(item)\n",
    "        else:\n",
    "            self.buffer[self.next_id] = item\n",
    "        self.next_id = (self.next_id + 1) % self.size\n",
    "        \n",
    "    def sample(self, batch_size):\n",
    "        idxs = np.random.choice(len(self.buffer), batch_size)\n",
    "        samples = [self.buffer[i] for i in idxs]\n",
    "        states, actions, rewards, next_states, done_flags = list(zip(*samples))\n",
    "        return np.array(states), np.array(actions), np.array(rewards), np.array(next_states), np.array(done_flags)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def play_and_record(start_state, agent, env, exp_replay, n_steps=1):\n",
    "\n",
    "    s = start_state\n",
    "    sum_rewards = 0\n",
    "\n",
    "    # Play the game for n_steps and record transitions in buffer\n",
    "    for _ in range(n_steps):\n",
    "        qvalues = agent.get_qvalues([s])\n",
    "        a = agent.sample_actions(qvalues)[0]        \n",
    "        next_s, r, done, _ = env.step(a)\n",
    "        sum_rewards += r\n",
    "        exp_replay.add(s, a, r, next_s, done)\n",
    "        if done:\n",
    "            s = env.reset()\n",
    "        else:\n",
    "            s = next_s\n",
    "        \n",
    "    return sum_rewards, s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Target network\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "target_network = DQNAgent(agent.state_shape, agent.n_actions, epsilon=0.5).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learning with... Double DQN \n",
    "Here we write a function similar to tabular q-learning. We will calculate average TD error per batch using the equation: \n",
    "\n",
    "$$ L =  \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\hat{q}(s_{i}^{'},\\argmax_{a^{'}} \\hat{q}(s_{i}^{'}, a^{'};w_{t});w^{-}_{t})  \\right) – \\hat{q}(s_i,a_i;w_t) \\right]^2$$\n",
    "\n",
    "\n",
    "$$ \\nabla_w L =   - \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\hat{q}(s_{i}^{'},\\argmax_{a^{'}} \\hat{q}(s_{i}^{'}, a^{'};w_{t});w^{-}_{t})  \\right) – \\hat{q}(s_i,a_i;w_t) \\right] \\nabla \\hat{q}(s_i,a_i;w_t)$$\n",
    "\n",
    "\n",
    "$\\hat{q}(s',A;w^{-})$ is calculated using target network whose weights are held constant and refreshed periodically from the agent learning network. \n",
    "\n",
    "Target is given by following:\n",
    "* non terminal state: $r_i + \\left( (1-done_i) . \\gamma .  \\hat{q}(s_{i}^{'},\\argmax_{a^{'}} \\hat{q}(s_{i}^{'}, a^{'};w_{t});w^{-}_{t}) \\right)$\n",
    "* terminal state: $ r_i $\n",
    "\n",
    "We then carryout back propagation through the agent network to update the weights using equation below:\n",
    "\n",
    "\n",
    "$$ \n",
    "\\DeclareMathOperator*{\\max}{max} w_{t+1} \\leftarrow w_t - \\alpha \\nabla_{w}L$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def td_loss_ddqn(agent, target_network, states, actions, rewards, next_states, done_flags,\n",
    "                    gamma=0.99, device=device):\n",
    "\n",
    "    # convert numpy array to torch tensors\n",
    "    states = torch.tensor(states, device=device, dtype=torch.float)\n",
    "    actions = torch.tensor(actions, device=device, dtype=torch.long)\n",
    "    rewards = torch.tensor(rewards, device=device, dtype=torch.float)\n",
    "    next_states = torch.tensor(next_states, device=device, dtype=torch.float)\n",
    "    done_flags = torch.tensor(done_flags.astype('float32'),device=device,dtype=torch.float)\n",
    "\n",
    "    # get q-values for all actions in current states\n",
    "    # use agent network\n",
    "    q_s = agent(states)\n",
    "\n",
    "    # select q-values for chosen actions\n",
    "    q_s_a = q_s[range(\n",
    "        len(actions)), actions]\n",
    "\n",
    "    # compute q-values for all actions in next states\n",
    "    # use agent network (online network)\n",
    "    q_s1 = agent(next_states).detach()\n",
    "\n",
    "    # compute Q argmax(next_states, actions) using predicted next q-values\n",
    "    _,a1max = torch.max(q_s1, dim=1)\n",
    "\n",
    "    #use target network to calclaute the q value for best action chosen above\n",
    "    q_s1_target = target_network(next_states)\n",
    "\n",
    "    q_s1_a1max = q_s1_target[range(len(a1max)), a1max]\n",
    "\n",
    "    # compute \"target q-values\" \n",
    "    target_q = rewards + gamma * q_s1_a1max * (1-done_flags)\n",
    "\n",
    "    # mean squared error loss to minimize\n",
    "    loss = torch.mean((q_s_a - target_q).pow(2))\n",
    "\n",
    "    return loss\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def epsilon_schedule(start_eps, end_eps, step, final_step):\n",
    "    return start_eps + (end_eps-start_eps)*min(step, final_step)/final_step\n",
    "\n",
    "def smoothen(values):\n",
    "    kernel = gaussian(100, std=100)\n",
    "    kernel = kernel / np.sum(kernel)\n",
    "    return convolve(values, kernel, 'valid')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Main loop\n",
    "\n",
    "We now carryout the training on DQN setup above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_agent(env, agent, target_network, optimizer, td_loss_fn):\n",
    "    \n",
    "    state = env.reset()\n",
    "    # let us fill experience replay with some samples using full random policy\n",
    "    exp_replay = ReplayBuffer(10**4)\n",
    "    for i in range(100):\n",
    "        play_and_record(state, agent, env, exp_replay, n_steps=10**2)\n",
    "        if len(exp_replay) == 10**4:\n",
    "            break\n",
    "    print('Finished filling buffer with: {} samples'.format(len(exp_replay)))\n",
    "\n",
    "    mean_rw_history = []\n",
    "    td_loss_history = []\n",
    "    state = env.reset()\n",
    "    for step in trange(total_steps + 1):\n",
    "\n",
    "        # reduce exploration as we progress\n",
    "        agent.epsilon = epsilon_schedule(start_epsilon, end_epsilon, step, eps_decay_final_step)\n",
    "\n",
    "        # take timesteps_per_epoch and update experience replay buffer\n",
    "        _, state = play_and_record(state, agent, env, exp_replay, timesteps_per_epoch)\n",
    "\n",
    "        # train by sampling batch_size of data from experience replay\n",
    "        states, actions, rewards, next_states, done_flags = exp_replay.sample(batch_size)\n",
    "\n",
    "\n",
    "        # loss = <compute TD loss>\n",
    "        optimizer.zero_grad()\n",
    "        loss = td_loss_fn(agent, target_network, \n",
    "                          states, actions, rewards, next_states, done_flags,                  \n",
    "                          gamma=0.99,\n",
    "                          device=device)\n",
    "\n",
    "        loss.backward()\n",
    "        grad_norm = nn.utils.clip_grad_norm_(agent.parameters(), max_grad_norm)\n",
    "        optimizer.step()\n",
    "\n",
    "        if step % loss_freq == 0:\n",
    "            td_loss_history.append(loss.data.cpu().item())\n",
    "\n",
    "        if step % refresh_target_network_freq == 0:\n",
    "            # Load agent weights into target_network\n",
    "            target_network.load_state_dict(agent.state_dict())\n",
    "\n",
    "        if step % eval_freq == 0:\n",
    "            # eval the agent\n",
    "            mean_rw_history.append(evaluate(\n",
    "                make_env(ENV_NAME, seed=step), agent, n_games=3, greedy=True, t_max=1000)\n",
    "            )\n",
    "\n",
    "            clear_output(True)\n",
    "            print(\"buffer size = %i, epsilon = %.5f\" %\n",
    "                  (len(exp_replay), agent.epsilon))\n",
    "\n",
    "            plt.figure(figsize=[16, 5])\n",
    "            plt.subplot(1, 2, 1)\n",
    "            plt.title(\"Mean reward per episode\")\n",
    "            plt.plot(mean_rw_history)\n",
    "            plt.grid()\n",
    "\n",
    "            assert not np.isnan(td_loss_history[-1])\n",
    "            plt.subplot(1, 2, 2)\n",
    "            plt.title(\"TD loss history (smoothened)\")\n",
    "            plt.plot(smoothen(td_loss_history))\n",
    "            plt.grid()\n",
    "\n",
    "            plt.show()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "#setup some parameters for training\n",
    "timesteps_per_epoch = 1\n",
    "batch_size = 32\n",
    "total_steps = 5 * 10**4\n",
    "\n",
    "# set exploration epsilon \n",
    "start_epsilon = 1\n",
    "end_epsilon = 0.05\n",
    "eps_decay_final_step = 2 * 10**4\n",
    "\n",
    "# setup spme frequency for loggind and updating target network\n",
    "loss_freq = 50\n",
    "refresh_target_network_freq = 100\n",
    "eval_freq = 1000\n",
    "\n",
    "# to clip the gradients\n",
    "max_grad_norm = 5000\n",
    "\n",
    "#set up random numbers\n",
    "seed=0\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed) \n",
    "\n",
    "#init environment\n",
    "ENV_NAME = 'CartPole-v1'\n",
    "env = make_env(ENV_NAME, seed)\n",
    "state_dim = env.observation_space.shape\n",
    "n_actions = env.action_space.n\n",
    "\n",
    "#init agent, target network and Optimizer\n",
    "agent = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())\n",
    "optimizer = torch.optim.Adam(agent.parameters(), lr=1e-4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "buffer size = 10000, epsilon = 0.05000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████| 50001/50001 [05:48<00:00, 143.64it/s]\n"
     ]
    }
   ],
   "source": [
    "train_agent(env, agent, target_network, optimizer, td_loss_fn=td_loss_ddqn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "final score: 566\n"
     ]
    }
   ],
   "source": [
    "final_score = evaluate(\n",
    "  make_env(ENV_NAME),\n",
    "  agent, n_games=30, greedy=True, t_max=1000\n",
    ")\n",
    "print('final score: {:.0f}'.format(final_score))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Let us record a video of trained agent**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_animation(env, agent, save_dir):\n",
    "    \n",
    "    try:\n",
    "        env = gym.wrappers.Monitor(\n",
    "            env, save_dir, video_callable=lambda id: True, force=True, mode='evaluation')\n",
    "    except gym.error.Error as e:\n",
    "        print(e)\n",
    "\n",
    "    if not os.path.exists(save_dir):\n",
    "        os.makedirs(save_dir)\n",
    "        \n",
    "    state = env.reset()\n",
    "    reward = 0\n",
    "    while True:\n",
    "        qvalues = agent.get_qvalues([state])\n",
    "        action = qvalues.argmax(axis=-1)[0]\n",
    "        state, r, done, _ = env.step(action)\n",
    "        reward += r\n",
    "        if done:\n",
    "            print('Got reward: {}'.format(reward))\n",
    "            break\n",
    "            \n",
    "def display_animation(filepath):\n",
    "    video = io.open(filepath, 'r+b').read()\n",
    "    encoded = base64.b64encode(video)\n",
    "    return HTML(data='''<video alt=\"test\" controls>\n",
    "                <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\" />\n",
    "                 </video>'''.format(encoded.decode('ascii')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Got reward: 650.0\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<video alt=\"test\" controls>\n",
       "                <source src=\"data:video/mp4;base64,AAAAIGZ0eXBpc29tAAACAGlzb21pc28yYXZjMW1wNDEAAAAIZnJlZQAAhbNtZGF0AAACoQYF//+d3EXpvebZSLeWLNgg2SPu73gyNjQgLSBjb3JlIDE2MSAtIEguMjY0L01QRUctNCBBVkMgY29kZWMgLSBDb3B5bGVmdCAyMDAzLTIwMjAgLSBodHRwOi8vd3d3LnZpZGVvbGFuLm9yZy94MjY0Lmh0bWwgLSBvcHRpb25zOiBjYWJhYz0xIHJlZj0zIGRlYmxvY2s9MTowOjAgYW5hbHlzZT0weDM6MHgxMTMgbWU9aGV4IHN1Ym1lPTcgcHN5PTEgcHN5X3JkPTEuMDA6MC4wMCBtaXhlZF9yZWY9MSBtZV9yYW5nZT0xNiBjaHJvbWFfbWU9MSB0cmVsbGlzPTEgOHg4ZGN0PTEgY3FtPTAgZGVhZHpvbmU9MjEsMTEgZmFzdF9wc2tpcD0xIGNocm9tYV9xcF9vZmZzZXQ9LTIgdGhyZWFkcz0xMiBsb29rYWhlYWRfdGhyZWFkcz0yIHNsaWNlZF90aHJlYWRzPTAgbnI9MCBkZWNpbWF0ZT0xIGludGVybGFjZWQ9MCBibHVyYXlfY29tcGF0PTAgY29uc3RyYWluZWRfaW50cmE9MCBiZnJhbWVzPTMgYl9weXJhbWlkPTIgYl9hZGFwdD0xIGJfYmlhcz0wIGRpcmVjdD0xIHdlaWdodGI9MSBvcGVuX2dvcD0wIHdlaWdodHA9MiBrZXlpbnQ9MjUwIGtleWludF9taW49MjUgc2NlbmVjdXQ9NDAgaW50cmFfcmVmcmVzaD0wIHJjX2xvb2thaGVhZD00MCByYz1jcmYgbWJ0cmVlPTEgY3JmPTIzLjAgcWNvbXA9MC42MCBxcG1pbj0wIHFwbWF4PTY5IHFwc3RlcD00IGlwX3JhdGlvPTEuNDAgYXE9MToxLjAwAIAAAAIcZYiEACf//vWxfApqyfOKDOgyLuGXJMmutiLibQDAFQ+wAAADAAATKpYnsyAlGpfAAAAQkANQH0GUHmImKsVAleIOLiWowB9oQCB8Gh8Yx4r+iSfQw2OGHQsVk4QycJqNU8j7ER7fF5aRnHV2EkgSiEBLHNtbvyKggu1XT2Ox3FOib8wj6CMuWXOTket5HBymlTN+UBppFlfQau8OKbOWYDcqta5ygYlOr0Tcq4TT60kyJ30kduqv65uQ/S3xKh+eOPBODz/dG+tq6Nhw9gJCFmAKrCzVG7u56FXT1j0AVvlp7XpEeD0KEUPQ2K/SGWAaCKpNFKMQTU3KHP90QPg8Ggt/V46RB6Yvgn/avsmVn66rCHxSI3iwnpHwZKE0v5Pp85u12t2sbyIOwCEGykdW+ldrUqT9+1ytla9fLef84XqjASDvlkGXBl/u3RZj4Pf944okoZilvqD5lPf2yEACcOARcEGzEFi0rfAj0I0AdHMuLSFQBpHpcC9XKHjWut7/fNqmlY4jw8d7SdTcCW4NNWe9tnZ8jacmWeENsdpKnN3z6RBHWu16R4vAFDSFh7NZ4qPL1HPRMSGtzDEEjTbtUMUILU+r7oGDA+8XzCeB8+ruCADMnP4FeWFiaWOMxlACT7RKQBEjBca9SMCchUN8266ZzQ4tqZUMspw7c5H4X8dpaThcAAADAOYAAIG2AAADAAADAAADAAADAAsJAAAAn0GaJGxC//6MsAAAGp2+YkrYHcQ/mf9QcaszHvonH+ulFbD30uGr4+eGffJCL+mkTE21v9JurhnmNWAJQkDTcSKR4o/XSoZGCm2PMQ/0tx5AbOTtbdbJysvfrsgssxMZDH5iRIagPqb+8ioRnmzWr9T8LDYrxQkZf29E5mt+ZY/CMrPEex+QP5FOMkN3NJhk26+URHmOVtQmyKK7McocNgAAAClBnkJ4hH8AAAhwLhuxDXMglQ8lCgwXQmB9YbnAu40anoBWuTXk6XNC9wAAADABnmF0R/8AAAUc9NRn5wXsqEHsjHhxFYhlxwAPviFNMtMoXmP36cAtBm0RXnSq0qAAAAAbAZ5jakf/AAANhJ6XeJuREaYiCPw85TCSYAy5AAAAV0GaaEmoQWiZTAhX//44QAABDRC8AQkqjH84Xb4DieiZmHq3d/7Qa1j8WO0Pe89mbX76NjNsTt1hJQqyz3AaUKDHuh8ifUjW+0v1fy1+ZZ/jGdYd+h/XMQAAADNBnoZFESwj/wAAFrVfTF4kSIGSAZMmciAYjCnKZFEwjzCVy/djMS4qXyTxCcUM+3Krp3UAAAAmAZ6ldEf/AAAjwzDxw4efCjpkLcz2xdwBhEmaYQ15hOfrRJUEB80AAAAqAZ6nakf/AAAN1IwB0XiUH72iNTRsi7i86kUSc/gACdnkWnNT4nKDxIFNAAAAaEGarEmoQWyZTAhP//3xAAADAPkhczYL7/wAgUkw8HSYB9LUcOh0x/R6SKbqdZLYo02FEV3wSFYNYM1IYSzDkzx37XzBINwP/D8cDZNAuJv4+MiIK7932UkCY5IGDNvSgOHOnuH3c67AAAAAM0GeykUVLCP/AAAIsU3FlmahdYcx2WOn3iXufSIYvgBB8UspQVC4F2BNTqsWxMKVU6Q3vwAAACABnul0R/8AAA3N2mAJLp/CwJaomcOnce1NIyrRh9x6QAAAABsBnutqR/8AAA3UkMzoBpvRzw7T7ON2Z1V3zkgAAABXQZrwSahBbJlMCF///oywAABGLvtGc+gGpUyBqHrAi9uNSNAZL0bGvR6vkMSs5wKjH9I4qRjZwStsah7rON1sUgmp8mE08iUh4pbQ/qAQt2ckY9HOLwZxAAAANEGfDkUVLCP/AAAWpRHRRwrJUi40fRm+WHWoJoABM1ApAb/o7FQn5kDlYvnhbuLWtOmePfEAAAAcAZ8tdEf/AAAkwxcUgePxeAgnjCUnTP1wXABDwQAAAC4Bny9qR/8AACTHv4a6bO1uG58sGPOh8kdk50AF0/iUWpECRxKpu7Rl5CTUov7YAAAAS0GbNEmoQWyZTAhX//44QAAAJqfsSaGGdhpo1eYxgAnUhkd3Oz4mBt0XTmhffLCv9YfpKgvml7XrX12vbWkR7uT4CakdHrOaAKEbSAAAACZBn1JFFSwj/wAACLFQIQtTxzpAgyOK8oBJ7mcDcP+/f2bynaCT4QAAAB8Bn3F0R/8AACOf+pnsVz3htscsrEKdg18hZs65Xq2oAAAAHAGfc2pH/wAADdSeJt8Tcffmn3b0lxTtbgeYCXgAAAB+QZt4SahBbJlMCE///fEAAAMCn0/dAPny3mAp0XyseuYEr9WxixrfOm2bC+vNgOg2RVEfMQcRyN4xUDM02bMD2QCEPSg6JCdksOxYhBywsBe2tWbpVDJRvNgA40ghORz850v/t0aHJBNd5hqXYZauKG6mWalSPsHniSyAGziBAAAAMEGflkUVLCP/AAAWtV9PWp7uKOaSkJQAmk+V34YvuwFM+Ibq4KH88th+5k7O2URdDgAAABsBn7V0R/8AACPDRwilDlZJ7AhShsyJooK+TukAAAAdAZ+3akf/AAAN1J6Xd6BfRYtd+vBsacqK6ZKfe4EAAACGQZu8SahBbJlMCE///fEAAAMAX9AICGoALWjd4re4eBihWIjuSBipbCdMDwNE2YPb19AgYzqw7eoJSivoWasUv4jR5uvcKXGO0TulBUAzklIhQUU+WFFX6uT4vl649dWCwn6KybGCWBO8QlYH3PfZmCl6vH/FHis7FEd8HA2bRSIkXEVs1VQAAAAkQZ/aRRUsI/8AAAixUCEdjGUpbSwgwdc1w+vxt0L80wL+2AmZAAAAIwGf+XRH/wAADc4Th283XioWAz4Ayui9AAmlJ//IH0vLXl3AAAAAGgGf+2pH/wAADdSd3scGX1cwZddY/q3pXz0xAAAAP0Gb4EmoQWyZTAhf//6MsAAACgcdS+8DTDW/Pub/rCKlQopYv7Nj5kyePSwg6rlgSvU6iN53AUPKUM/04A+DgQAAACJBnh5FFSwj/wAACLFM4bXBH4YoXXQ1ro9PvAjmKYjKKu9TAAAAIgGePXRH/wAADc4KO2HlfvP+VZrEml63rOgnDiAAEznc9MAAAAAbAZ4/akf/AAAN1JZFjlJck1uO+yjvke6QqweBAAAAZ0GaJEmoQWyZTAhf//6MsAAARgLaWcAUG2nQGksYBVqmlik9SEMmd65dDI3CKIN0Vc+9zYfM7zPtF9IEOA8TBvnfS+vZn7pDYp7TDcrV1SHDfYhArmHbPYsOJsnOOp/KDFNFhM6GLPAAAAAwQZ5CRRUsI/8AABa8ULhRgzMoIfcAQcf/gsCeqSl8lNmcZbZKu2g56QAapBeSk9VNAAAAIwGeYXRH/wAADc4KO2lWkOZEEhT26RGzwqMAABIdfzf+dBNwAAAAIAGeY2pH/wAAI78fjBvhDKbirBv5DXz1T78qF6aLgHuBAAAAaUGaaEmoQWyZTAhf//6MsAAARi8MaOfADb8aWli0mcJR82CJUYwqd19Ji40W6/Ybbcea5wITvqzQMV3ObYnjaCPwd/1hDXpAi6wY4vEea7SYywhKQUVHg8vdWyxiy3yNjbRWRHHFvh2PwQAAACJBnoZFFSwj/wAAFrxQuFKpoFIlQL/J5IhbmEFFuLERU5uBAAAAEwGepXRH/wAADc4T72dGvSqqnL0AAAAdAZ6nakf/AAAjvx+MRnGKcOkM+xRPd4YoNG4MwIAAAAA0QZqsSahBbJlMCFf//jhAAAAFhtYkAITUxcv12ttfOLO7Kg8BwD1uPLCs0RwBTBN1mXpBwAAAACxBnspFFSwj/wAAFsCgUmalMkiQY5OHA3ZvLFr2SkEguPRz5V9D+AgPWbL5gQAAACsBnul0R/8AACPDRwik7uLQgALoAU/o2vxKmbjz2e9NCHF2fGQ+LEy+ufgMAAAAIAGe62pH/wAAI78fjEaHJxrypuKQrHUOfZlElIrJNPswAAAANUGa8EmoQWyZTAhH//3hAAADAJcrk3V+B3RR7UcfEvWcoCAxIPGvfNPjLVQiewaUO0H2FnjBAAAANUGfDkUVLCP/AAAWwFoVyZtEtA+cO+cQCb9LSNHXeisnl00HsFYte5RePSdEQcXLHfQAy0T5AAAALQGfLXRH/wAAI8NHCI87Q+qeI2AC0Z86rb0+dWtQbjBIhk/rlJX4RDRSGr/NswAAACQBny9qR/8AACO/H4w3wE6wyL1Ego3F2D3+hiT5rTS6btrU7bMAAAA7QZs0SahBbJlMCGf//p4QAABFRSZvq9JATRNNqI3j+9pFx4Xc0tV41DnGG8qWlLQ5Akk947q6nOFxk9oAAAA4QZ9SRRUsI/8AABbAoFJlJCokCQyIplAB+5LtLwL1Zb4PZDa9ZE829KQD25Jp/3+7fm8yS8Ab74EAAAAuAZ9xdEf/AAAjw0cITt+EAEiiF3APv/2S7NNSOXiYuUMVJWXsdOC0KUDIiKVioAAAACQBn3NqR/8AACO/H4xHIFe2NpmMCt3YpKDBq9n0yMZglz20QmAAAAAgQZt4SahBbJlMCGf//p4QAAAJ76srPnoTPmC2cbRORMEAAAA0QZ+WRRUsI/8AABbA0AQARi3C2kXkydrEoGqyOjCvzvPnZcblVSyQ4rQ1KjjOcKbRNsjo4AAAAB0Bn7V0R/8AACPDRwimP8rHR5ruorRpXv4uh4nDZwAAAB4Bn7dqR/8AACM+mELATNfmRcBjdZlWd3z2ORBBy4EAAAAnQZu8SahBbJlMCGf//p4QAABFbV+yVAZsfcYUWypygBTFejdmq/m4AAAAGUGf2kUVLCP/AAAWvFC4UqllJ2HyPyUFjX0AAAAPAZ/5dEf/AAANzhPsAI2AAAAAEwGf+2pH/wAAI78fjEZufw9kQcEAAAAxQZvgSahBbJlMCF///oywAABGLAGufQ/UbbnFBFtgmoADkxuU34PxHZV+WCKPCdhE3QAAACNBnh5FFSwj/wAAFrVfT1qO2rQ0KRJE0VdR34BunoJ5sDsZ8AAAABoBnj10R/8AACPDRwik3tfqUhE7v8r9rA3+2AAAACMBnj9qR/8AAA3UnhbXi1KYQAPVMfRvrDZDLZaVT5O2SM7fbQAAABtBmiRJqEFsmUwIX//+jLAAAAMACpVS0sdgxYAAAAAiQZ5CRRUsI/8AABZx4chHC6NvabQkDnUtLzpQAFtANIk+cwAAABMBnmF0R/8AACPDRwik3P5XsMCAAAAAEwGeY2pH/wAAI78fjEZufw9kQcEAAAAeQZpoSahBbJlMCFf//jhAAAADAg3uLiOzTXeLxLaBAAAALUGehkUVLCP/AAAWwKBSZqO2LmaC/FTF+SoAJ1hHLI9dT/dXL79mWUzzLkXocQAAABQBnqV0R/8AACPDRwik3P5U6aXPgQAAADUBnqdqR/8AACO/uiADh9yJKGL4zE3Qv5IEgi2iLPBGZcC8PfN9RFtAQe94T4VBMWegRXINswAAABpBmqxJqEFsmUwIT//98QAAAwAAaUqQ/hGJ2AAAAC9BnspFFSwj/wAAFsCgUmajtnOoZtwfrFwAQ/CA9T6Kf61nlb5Av2p8mgnyez5z4QAAABkBnul0R/8AACPDRwik3tfqUhE7xA/EHH+2AAAAIQGe62pH/wAAI7+6IAOH3IkoYvjMTfoOOjNufU/TU/ItswAAACRBmvBJqEFsmUwIT//98QAAAwKfBXmQEzZJ5eZ+/VGFkPMI6oEAAAAwQZ8ORRUsI/8AABbAoFJmMGDT/BS87GAEtUCkBv+jsVAG2HxsNK+YJvoazYLh0NcdAAAAHQGfLXRH/wAAI7aQ8JzSgstRDv2UWjsPOnuPDhsxAAAAJgGfL2pH/wAAI7+6IAOH3IkoYvgt4ZchqOeNDKSnggkgi0yk5UHAAAAATUGbNEmoQWyZTAhn//6eEAAARUiXIA5RvBaLJClkTBhh+YCptj4txNE4vRkjtzAeh630GsL1xJupJRMkDFvKKz0VNIGw29mOJPV/f2FNAAAAM0GfUkUVLCP/AAAWwKBSYVqzpOXCuAATttD1yWu4TFKCXvkqcb2lVK6SaHzHTkHNeDE3wQAAAB4Bn3F0R/8AACO4w8JFsKP7zN3nzs5w2YKmx/ZGSxYAAAAgAZ9zakf/AAAjvZad/T7Xg71Dz3mZUSJEa5qyCI8m5GAAAABQQZt4SahBbJlMCGf//p4QAABFceTttsAOl9Mbmhv0BPfh+Tw3Ll8o3iDkMd2JX4/hxIdEvb4Of6ZJmu/q+O2fQlFgieSEqmvnYQefsHuEYEEAAAAzQZ+WRRUsI/8AABa1X09auWb53DP5JKaAK3igxaY4URMaDnUHnbk53ouLyOZpgq/3vG44AAAAIAGftXRH/wAAI8NHCKY2ymRJAh8QmFYwxi4SrBxNmUqZAAAAKAGft2pH/wAAI5/acQr/THC9fxIaoBfMup9g6N2ekYAAlp3MCLwnC2kAAAAhQZu8SahBbJlMCGf//p4QAAAJqkDOa2S/icNgIE15AYgYAAAAIEGf2kUVLCP/AAAWvqcuE1c8GKQJh0Fa5ybS3jIytAypAAAAGgGf+XRH/wAAI8NHCKY2ymPwF/rnAxuMFYfMAAAAFQGf+2pH/wAAI78fjEZva6/KUSObgQAAABdBm+BJqEFsmUwIZ//+nhAAAAMAAAMDPwAAABlBnh5FFSwj/wAAFsCgUmajti5mjXx5Ho1fAAAAEwGePXRH/wAAI8NHCKTc/lewwIAAAAATAZ4/akf/AAAjvx+MRm5/D2RBwQAAAChBmiRJqEFsmUwIZ//+nhAAAEVIlyATSlxef4CkZ9xNWzzBawdVySzgAAAAGUGeQkUVLCP/AAAWwKBSZqO2LmaNfHkejV8AAAATAZ5hdEf/AAAjw0cIpNz+V7DAgAAAABMBnmNqR/8AACO/H4xGbn8PZEHBAAAAJUGaaEmoQWyZTAhf//6MsAAARhTKU8KN97oBsN2BN8hQbEnlms8AAAAZQZ6GRRUsI/8AABbAoFJmo7YuZo18eR6NXwAAABMBnqV0R/8AACO4w8JX72zxJEHBAAAAEwGep2pH/wAAI78fjEZufw9kQcAAAAAfQZqsSahBbJlMCF///oywAAADAAdGLjgkQBVNR7CLgAAAABlBnspFFSwj/wAAFsCgUmajti5mjXx5Ho1fAAAAEwGe6XRH/wAAI8NHCKTc/ejsMCAAAAATAZ7rakf/AAAjvx+MRm5/D2RBwAAAAD9BmvBJqEFsmUwIV//+OEAAAAMATU6A1VIxb6sUTcaXJpbHNupv95gK6ALCbMDAgHVDH+qE/2yim3LnuvX/zcEAAAAdQZ8ORRUsI/8AABbAoFJmo7Yue0D8PeqrbnJ49HUAAAATAZ8tdEf/AAAjw0cIpNz+V7DAgQAAABkBny9qR/8AACO/H4xGb2Kz96FhL5aW7WDAAAAAKkGbNEmoQWyZTAhP//3xAAADAA2IsRr2vwPsRr0ABOTAS9IZD3hq6o2V8AAAACJBn1JFFSwj/wAAFsBaFcmbRN9wazhHifvyVCjO9hmpYmjhAAAAGgGfcXRH/wAAI8NHCI899HThMI7oSlBO5lkwAAAAHwGfc2pH/wAAI78fjDe/+C20esq5eAfzGPREfaLG03AAAAA/QZt4SahBbJlMCGf//p4QAABFgAENygEHo+pVq3GA9PFNN2hb1T5AuYJdZWT/QIncmnHDrI2AneyUK7N/g4gZAAAAI0GflkUVLCP/AAAWwKBSZSRtkexphEbrfw2Xrs4REv1Frv5gAAAAHQGftXRH/wAAI8NHCI83RS3RUdX25q4S0LG15Y5JAAAAHwGft2pH/wAAI78fjEavTWSq7be5D1/SDGwRUvbLnJEAAAAoQZu8SahBbJlMCGf//p4QAABFUj3IBNDcLzmiUkeshFmGQ07aUbJLiAAAACFBn9pFFSwj/wAAFr66XgCI3spCHZW4ScrMDNP4ExQyMF8AAAATAZ/5dEf/AAAjw0cIpNz+V7DAgAAAABMBn/tqR/8AACO9lp39zXtm6WGBAAAAF0Gb4EmoQWyZTAhn//6eEAAAAwAAAwM/AAAAGEGeHkUVLCP/AAAWwFoVyZ7Smzpe0JtRfAAAABMBnj10R/8AACPDRwik3P5XsMCAAAAAEwGeP2pH/wAAI78fjEZufw9kQcEAAAAXQZokSahBbJlMCF///oywAAADAAADA0IAAAAXQZ5CRRUsI/8AABbAoFJmo6fyl7QaWF8AAAATAZ5hdEf/AAAjw0cIpNz+V7DAgAAAABMBnmNqR/8AACO/H4xGbn8PZEHBAAAAG0GaaEmoQWyZTAhf//6MsAAAAwAHJ+I+e18j4QAAABdBnoZFFSwj/wAAFsCgUmajp/KXtBpYXwAAABMBnqV0R/8AACPDRwik3P5XsMCBAAAAEwGep2pH/wAAI78fjEZufw9kQcAAAAAXQZqsSahBbJlMCF///oywAAADAAADA0IAAAAXQZ7KRRUsI/8AABbAoFJmo6fyl7QaWF8AAAATAZ7pdEf/AAAjw0cIpNz+V7DAgAAAABMBnutqR/8AACO/H4xGbn8PZEHAAAAAFkGa8EmoQWyZTAhX//44QAAAAwAADKkAAAAXQZ8ORRUsI/8AABbAoFJmo6fyl7QaWF8AAAATAZ8tdEf/AAAjw0cIpNz+V7DAgQAAABMBny9qR/8AACO/H4xGbn8PZEHAAAAAQkGbNEmoQWyZTAhH//3hAAAEE3kVICEjGlIPv2UFOzl66kD6hEy7yuQQP33AimELJ8Yl9RBdhZUTnp9iX4ywtlHbegAAAB5Bn1JFFSwj/wAAFsCgUmTxbXmAi4awp+g+0HMMz4EAAAATAZ9xdEf/AAAjuMPCV+9s8SRBwAAAAB8Bn3NqR/8AACOUbVI242vgLnrAV/54AgAB3C5eaA+mAAAAaEGbeEmoQWyZTAhn//6eEAAARVI9yAOUbwE9ONlLb4rboMEcwf64Hwwtg1R4Y2sJtj+ZNInGc3feZbBPPpkr6Nu+Zn7312IY2cGq14a5yzkkx44rgxYIVALuIjNPyMzP0gqww+l+Pm2TAAAALkGflkUVLCP/AAAWqnW8e6YyV0fACqfYAD+dA2rwkcYMa3E1v0OJbo5ELhfAfmAAAAAfAZ+1dEf/AAAirELfEqCH1ABbwCFvteJY562u1EAuIQAAACoBn7dqR/8AACO/BCcYmaa35H1nAAAJTWuPp/+6GnMsuBp+EuyraKbQLZkAAAAqQZu8SahBbJlMCGf//p4QAABFRS1zgA6RExtjQoVRvASpU3yOS5sSADAgAAAAH0Gf2kUVLCP/AAAWwJs/UM0H77rS0nzXqiARdk9eC3EAAAAhAZ/5dEf/AAAjt/W0MF3EWgAW8AR81IDJ9y/VGj44bznwAAAAEQGf+2pH/wAAI78b2PWy/EHBAAAAF0Gb4EmoQWyZTAhf//6MsAAAAwAAAwNDAAAAFkGeHkUVLCP/AAAWwJs/ywmIclx1GF8AAAAQAZ49dEf/AAAjwz+x66PxBwAAABEBnj9qR/8AACO/G9j1svxBwQAAAC5BmiRJqEFsmUwIX//+jLAAAEYpYYkongRFMzTaIQ9V/Nz31U4dbD5RnyT544bMAAAAFkGeQkUVLCP/AAAWwJs/ywmIclx1GF8AAAAQAZ5hdEf/AAAjwz+x66PxBwAAABEBnmNqR/8AACO/G9j1svxBwQAAAEBBmmhJqEFsmUwIV//+OEAAAQ20Fkqw2AJ3Ll2DWBP9td0dmhWHjE4NPQS7/l1Y31oECh75lFsYx84RyPgdAk3BAAAAF0GehkUVLCP/AAAWwJs/ywmIbJ3JOxQfAAAAEQGepXRH/wAAI6TeUMSkeGIPAAAAEgGep2pH/wAAI78b2PWx60lz4AAAAB1BmqxJqEFsmUwIT//98QAAAwKfyGkFCwxqbx9UEAAAACxBnspFFSwj/wAAFqsgn/AESDQjf3fexYjkD+E48SbpDxV2vcYS6G5l5LDnwQAAABkBnul0R/8AACO4we9pj1sN+pOc6t3V7f53AAAAJAGe62pH/wAAI9UhABxN6hPIn1DkOoapTyVbZhmh6MFnEuiOSAAAACtBmvBJqEFsmUwIZ//+nhAAAEVFKaAAKYjTc0GdhhwCCJzy1zULAnJxAKaBAAAAOkGfDkUVLCP/AAAWwL58ARINCWGAPWvZmSld7XkWP49nLdXnuYUQ5fKz2aMhC6Ag6Wi8IhI2GCCTob8AAAAbAZ8tdEf/AAAjw0Cl0m7i2skfqtWXmn8cHKSZAAAAIAGfL2pH/wAAI78EJxLJaZkyZA5ELhCr3VioYKzXKd8GAAAALUGbNEmoQWyZTAhn//6eEAAARWjxdbl31FEVgkUHgPfle+GACEdNTaYxf7BnwAAAACtBn1JFFSwj/wAAFr3hJKAEY5Yf5lM8/0RLnU0vnoKshUlg9cPT9818cR8xAAAALQGfcXRH/wAAI7i4P/8XeoTEYABcTCXR85wVsenr6aP/++20F/FfRS99RTyAgAAAABoBn3NqR/8AACO/BCvIToP5H8i2uwFMkez1swAAACxBm3hJqEFsmUwIX//+jLAAAEYUylPuflrKII0gAVJvgPFMvGCUYRc4PR4K2QAAAB9Bn5ZFFSwj/wAAFsCbP8uyeKsaC/s5ThPv7XbzqeMQAAAALAGftXRH/wAAI7i4P9okBWRM0OjVhdbwXuKJ//vdLs49cio5EKf/9P+PjUgJAAAAKQGft2pH/wAAI7PUQAca+CMcmJyz4puWe67Q6LZwcfIIcx41ybcNW22ZAAAAM0GbvEmoQWyZTAhf//6MsAAARhHkQBAMhvDbDFPQGMZ6qqf+ZveWgmTwL7j7DQmH48E2YAAAAB5Bn9pFFSwj/wAAFrxDz4UwPRtMy25IcmAbYfiL3vkAAAAZAZ/5dEf/AAADABpvYIvuEDB7IxBBdOZ/BgAAABMBn/tqR/8AACO/BCvAcovUR2DBAAAAHkGb4EmoQWyZTAhX//44QAAAAwAcPvqACDrK7OJnXQAAABdBnh5FFSwj/wAAFsCbP8sJiGo5PvTUHwAAABQBnj10R/8AACOfTvvcLCO0MibPHAAAABMBnj9qR/8AACO/BCvAcovUR2DBAAAAF0GaJEmoQWyZTAhP//3xAAADAAADAB6QAAAAF0GeQkUVLCP/AAAWwJs/ywmIajk+9NQfAAAAEgGeYXRH/wAAI8MXdVFQ0STCggAAABcBnmNqR/8AACM9b3vtRDbjRemSovqDBwAAAIVBmmhJqEFsmUwIZ//+nhAAAEVvMlfpAA4Qg2HOhUqIg9pJmpn3IvDAPjHnNuj0gCIm67wFltQgiFm2cuGArLRgdmgTOySTsTl81jZShukyH6XTGEfGCrX6Bj6Ri1Yr7vrZMLwX6Q0oU4aHxUdK7A55WMiwMj2iAPK8w8FN1CBqKts1J+aNAAAANUGehkUVLCP/AAAWqnXEZqdpzocbACatY0AbiVTtUz37SvQ0Ab5m+D9FnHVAlkN/q5Hn3aOhAAAALgGepXRH/wAAI7f3kEAHGvgjHRzjBjq9RTg/uTD5oybnLBcqnMPhyi5e9YSCuLEAAAAWAZ6nakf/AAAjvwQnEsr+sLxG2LWDgAAAADhBmqxJqEFsmUwIX//+jLAAAEQRBegEAjcZaX2eLOeELQLxPGlNAdkFRhuoQqpGEEzt53t2np1rSAAAABdBnspFFSwj/wAAFnQ24qLWExK5ARLnwQAAABMBnul0R/8AACPDA6BocnISTODgAAAAEwGe62pH/wAAI78EK8Byi9RHYMAAAAAeQZrwSahBbJlMCF///oywAAAahz7AG4iQw2r+gAbNAAAAFkGfDkUVLCP/AAAWwJs/ywmIajkBz4EAAAAUAZ8tdEf/AAAjn1cIa4DlUWTZ44EAAAATAZ8vakf/AAAjvwQrwHKL1EdgwAAAAEFBmzRJqEFsmUwIV//+OEAAAQ0+t4lTGVN5oAQnItgtKH/M6dIORMQNYxrdSYvXSWJkhjaWmdErLxzxBQX0FxuFVwAAAClBn1JFFSwj/wAAFsifgCI2b5gqmfjCSTfj+vGk8T5DH9swfgB7xnaygwAAABIBn3F0R/8AACPDF3VRUNEkwoIAAAAcAZ9zakf/AAAjx72MGsssH78hjlGB1ITw6Ta/gwAAAB1Bm3hJqEFsmUwIT//98QAAAwAFGgoeAndSoI6hcQAAACFBn5ZFFSwj/wAAFr6jniC7aBNs9pK0ongqaexKNcwbNswAAAAcAZ+1dEf/AAAjwxd1WSLANq59+4F2ts0IpVX/VQAAABoBn7dqR/8AACO/BCvIToP5H8i2uwFMkez1swAAAB9Bm7xJqEFsmUwIZ//+nhAAAEVFJcy6cH+y+bBMTgK2AAAALkGf2kUVLCP/AAAWwFoCCMvf39MO5gAmagBqdOCoPoUcWUKuIeFFfygngJN9SQEAAAAqAZ/5dEf/AAAjwxdoqaVT1QZ37AAWQmOSt5cVeLZ7xbsE1k9ICotmHkgIAAAAJwGf+2pH/wAAI78EK/qOtQALcAYudpLWMBw0TngAieYmQDChR1JSAwAAAB9Bm+BJqEFsmUwIX//+jLAAAEYRrBEIaF9kOERB6lZxAAAALkGeHkUVLCP/AAAWtStDMoTNLgAF0BKW+Nv80wowBrHv6GGNQ3RaYSRP/TckzkgAAAAaAZ49dEf/AAAjwxd1aIoKA2ML2tydYOvQgIAAAAAcAZ4/akf/AAADAEWEEWy22keqfSDgD89jXU+HbwAAACJBmiRJqEFsmUwIX//+jLAAAEYHuQAX+2n21lonhOLAADpgAAAAFkGeQkUVLCP/AAAWvqOeIIM5X8VcufEAAAAaAZ5hdEf/AAAjpODogA43Ys5DHiwjo37DsGAAAAATAZ5jakf/AAAjvwQrwHKL1EdgwQAAABhBmmhJqEFsmUwIV//+OEAAAQ1RPJMABj0AAAAWQZ6GRRUsI/8AABbAmz/LCYhqOQHPgQAAABMBnqV0R/8AACO4uD/UVDew8KCBAAAAEwGep2pH/wAAI78EK8Byi9RHYMAAAABVQZqsSahBbJlMCE///fEAAAMCn8hpBRFc4RA8i8AAChy14BMxmhCIAlT+6YOIGXtbJndNG3J0APskgnQtnjviXGsXP2kjCrju9Mh1HAEHHw3ZwoDhgAAAADBBnspFFSwj/wAAFrydeAG67kyvp2qaDvjU9velJ5VCoBclJsQGXK0OmmjQWyPR8GEAAAASAZ7pdEf/AAAjwxd1UVDRJMKCAAAAHgGe62pH/wAAI8e9jCipNLGRUP6BVlmA/mCjtIZeDAAAAD1BmvBJqEFsmUwIX//+jLAAAEYC+t4Bd9HMhYbWzlJmj13fCZBO4d3kjNiIrlo8BFrt4QtxoGJVu1taB7EfAAAAMUGfDkUVLCP/AAAWvngSd4E3F2lZenDmgSAB7dd8CppVYyYQ+yoC/8l/abE/GM2QC28AAAAsAZ8tdEf/AAAjwxdoqaQHOAAJFCPmIF9AzZNdftH6KioBmdOrjbMTY9NvFRkAAAAbAZ8vakf/AAAjvwQryEmUwkcOE6lmbsfv1kmAAAAAOkGbNEmoQWyZTAhf//6MsAAARhIJcAKDbOm9gzMxhewysn0LqnmxS2qoaVleCV02oI9haXtBWKHhw+YAAAAtQZ9SRRUsI/8AABbAmz/LGftZU3uABMj0eBUz45H5dQfR16bbg82yLGjgdLixAAAAFwGfcXRH/wAAI8MXdVOK8mGnvAQu8S24AAAAGQGfc2pH/wAAI78EK8E5zdR5s9mtJrche2YAAAAqQZt4SahBbJlMCFf//jhAAAENQFYAYMHASnZOKWN9j7KYHLN0lLrsVkvBAAAAFkGflkUVLCP/AAAWvqSrQQZyv4jA58AAAAATAZ+1dEf/AAAjuK/eqioFjME4OQAAABMBn7dqR/8AACO/BCvAcovUR2DBAAAAFkGbuUmoQWyZTAj//IQAAAMAAAMAwIAAAAGdZYiCAAz//vbsvgU1/Z/QlxEsxdpKcD4qpICAdzTAAAOwKQAAAwACFXKud5AkucXwAAADAagAUELAI8JULYSEfY6Q3/BOPmAGAYmy/i+tg6FxYaxhu5M/orvzwZkPn03ULPjDNuYGWZN22ENhVeRQNPoD4k9sn82hjA3B4n8H0mQY6/vC9tF52o4NNL2vbG+80OBij/eqyJAOiAf0mA4Q6V85bBoowvoSdW89N3bmaAR6+b2X5gjJNHxLVW2tIiPe3u30PMs1eCkG+gM9e5bHBkRCq+oxBbHO67PaJFw2xtF1FiBD1VrV2Gf658NSvefXdgz1u4Gtu/YndzuOv/n1wqu+335hDu0Mu+KzhPkBLFx3mz9XUumGdZvgUvDicyBOweUlTf/we/Q2nxG2dFRMrjuKqs1zMou67U8w07qXAC4TL7XM+jdhAdrby567apFRkMLonNHJ7Kj9SgDMAIHKxBbCIGgQTxMQgTlVCBbLIcjJ1xVEO6uj67IB/BYhvEuhc+FLZKcChAADjUAAgP+AAAADAAADAAADAAADASUAAAB8QZokbEM//p4QAABFR2x3gBr3cLQZdgCpORh4HmKHexlypNUinM/hXFU3tLGgGKfe5y/Q0y8gXdTei7zqhUykdbwXv1dsySBHX+kWLNx8lCdQu1mo7Cy4HhYXvcrpV/QKg8ts0uiL3ZmB6+RAFWK3cFBCJFoI/1KXcQY+IwAAADVBnkJ4hH8AABazTMeAK33jvRJ7anRd6RARQndDctSJm/uSINHUlA23kyR0PfgiHXNSid1izQAAACgBnmF0R/8AACO6U4TWIM/YI6KtTwnz/zABOnk/oTNnH3u3sjV71qPhAAAAIgGeY2pH/wAAI78EJ9v+zKxmHu1kAeQRlFcIaHrpI9sRICAAAAA3QZpoSahBaJlMCF///oywAABGAvaROEY7x2BATPfws3I3TYQkRKesUwoB9fiteLyd7iwdLwIteQAAAB9BnoZFESwj/wAAFr3gaDyJk/9EPVYIRSuBP2bAhxHxAAAAFQGepXRH/wAAI7i3Fia/xumSpfAGDAAAABYBnqdqR/8AACO5ziViZIg3TJLNEFg5AAAAF0GarEmoQWyZTAhf//6MsAAAAwAAAwNCAAAAF0GeykUVLCP/AAAWuTi73wkH25SbwHrhAAAAEQGe6XRH/wAAIsM/sfagSYOfAAAAEgGe62pH/wAAI78b2PWx60lz4QAAABZBmvBJqEFsmUwIV//+OEAAAAMAAAypAAAAE0GfDkUVLCP/AAAWMJ+QMl1OxDwAAAAQAZ8tdEf/AAAiwz+x66PxDwAAABEBny9qR/8AACK/G9j1svxDwQAAAHRBmzRJqEFsmUwIT//98QAAAwKfmBXaNmGlhz9eZD0gAQlYmsO5MVVNY9gxrbzMMoGvcepeO2Ak+lHZSfI1neKOoSVmaBHg3iOWhRNfMWE+Gl5fHti8AHFiFuAtgVzLoIDz0MB0nZEqqVyfQB3UuZOdfgn+wAAAACJBn1JFFSwj/wAAFrxDz5pZzchqBYf74TjBjdbOANjb3fhuAAAAIAGfcXRH/wAAI8C438HIqgAshMSICY1q2XYjV/XeAEbBAAAALQGfc2pH/wAAI72WAoo9ZQALUTEiAmNatl2I1f2MOlcqpiEvQbSTEM0awdxckwAAADpBm3hJqEFsmUwIX//+jLAAAEYQ/reA0jULM/Ozf8nDo9RzSYebkMinW0Y5loH2aOyNj0jiaT+DuEuJAAAAKEGflkUVLCP/AAAWtSs3a1peuJ1IgDUPIgo7ZCdCF8nY8cHl7ExuEBAAAAAfAZ+1dEf/AAAjsKttUv3ezIvclDCUOXIGGgnFunktmAAAAC0Bn7dqR/8AAAMAuiYB7alAAtRLw8+rS0VoIvqZZ//BpidPsh23OLVXaqZA5IEAAAAWQZu8SahBbJlMCFf//jhAAAADAAAMqAAAABdBn9pFFSwj/wAAFrk41eDjIPtH8lIHrgAAABIBn/l0R/8AACPDF3VRUNEkwoMAAAASAZ/7akf/AAAjvxvY9bHrSXPgAAAAP0Gb4EmoQWyZTAhP//3xAAADAp/IaQUNYd4EAEQdvoyhiGtp3pA90SzOBq6PolbRqDvpECYnBfQcBvXqqb/DoQAAACBBnh5FFSwj/wAAFrUrQ1GQ9Ycwo10rnOetjt+lMp7bMQAAABIBnj10R/8AACPDF3VRUNEkwoIAAAAdAZ4/akf/AAAjx72MH5ph9y49OixFqYKLql1SZ28AAAAmQZokSahBbJlMCF///oywAABGAvbyegYCAmfm1wI85U9/w4bbgSsAAAA0QZ5CRRUsI/8AABa+eBPoZe/v5LHJ++ZQbzrJyxbbYyZEpsNEntEudQyLJ9QEXHi5hfkDtwAAAB0BnmF0R/8AACPDF2ippVPVBkqlLNajKGh8MPJAQQAAACoBnmNqR/8AACO/BCv6ifjOgTAAWs/mkaHdUP0KQ7B//RdZZoLLFtHyRyQAAAAeQZpoSahBbJlMCFf//jhAAAENPreJUwOSgZ7ViVkvAAAAKkGehkUVLCP/AAAWtStDJvUM+IAC6i5GTfNMSyrTiu9P0oHKKfLBhNzO3QAAABgBnqV0R/8AACPDF3VZL9O3zlZxqUyJfJMAAAAaAZ6nakf/AAADABprBq4NggbT8OETvH+e3wcAAAAhQZqsSahBbJlMCE///fEAAAMA8nJYBNLDKMxZqZMoadK2AAAAFkGeykUVLCP/AAAWvqOeIIM5X8VcufEAAAASAZ7pdEf/AAAjwxd1UVDRJMKDAAAAEwGe62pH/wAAI78EK8Byi9RHYMEAAABcQZrwSahBbJlMCF///oywAABGEP25f5+TSBQunJoiD0QDMNr3LnDgukhv3708JxgdTSbV81TlFxSWxxaa5tITM8DPBAhYI2ZmSYxacWPs+cK+iP8FL6aAFsMFgCEAAAAsQZ8ORRUsI/8AABa7lFTGKoArQHIXThNSr9yLlVsX85wa5YWFZcNgIcgE8GAAAAAhAZ8tdEf/AAAjq+t4cKg9wAONy7e47JByFzbLgjWLwAjYAAAAIAGfL2pH/wAAI78LKi5P9+gADoQYbDsIdtuknKed8uclAAAAIUGbNEmoQWyZTAhX//44QAABDT8DkaWDJFCy0Hj7/gFKzgAAABtBn1JFFSwj/wAAFrUrQyK8JJzEXGwWQiKLrBgAAAAXAZ9xdEf/AAAjwxd1U4ryYae8BC7xLbkAAAAiAZ9zakf/AAADAAo+YaocAENZ+Xesj+qF/e1lbeMYPP2+LQAAAC1Bm3hJqEFsmUwIT//98QAAAwKfBRu8QHFDr5ACZroZTy4+sximbfxrMygAj4EAAAAfQZ+WRRUsI/8AABa+oOB8PEUcgpDJyZDAAOMaqG7BgAAAABIBn7V0R/8AACPDF3VRUNEkwoIAAAAVAZ+3akf/AAAjvwQnEqc4TWDIggYNAAAALkGbvEmoQWyZTAhX//44QAABDSpGTK094D+pYjK8GD7KlpngzhcPxYvyTqyFt6IAAAAiQZ/aRRUsI/8AABa8RZkZyKyLC+1tBPtdoHWferc9MKnbgAAAABgBn/l0R/8AACLDRwhqUEGKjgBnn2p4D5kAAAArAZ/7akf/AAAjvwQryEmUs6BMACHqMnQ1Bo66MfHyv+42RPQwHBxvcIFtwAAAACZBm+BJqEFsmUwIT//98QAAAwKfyGq2gH3xZMKhYlCKevd23dvnQQAAABpBnh5FFSwj/wAAFrxDz4QrlXlADhKYBxKUnQAAAA4Bnj10R/8AAAMAAAMBqQAAABQBnj9qR/8AACO/BCvAcovOzLOHgQAAAD5BmiRJqEFsmUwIT//98QAAAwKj7Dg1MgzYkrrsEhO2ZzJ5HxplO+DgSAke0IQheKO+R76wU2QjEK9tnwtKaAAAABxBnkJFFSwj/wAAFrNCuPWKTWcaAL9gwPXa6IfBAAAAFAGeYXRH/wAAI7CjEYLCPBGNP5w9AAAAFgGeY2pH/wAAI78EJxLJabEzrUmQwcAAAABbQZpoSahBbJlMCFf//jhAAAEFOglqALhxi+45snvbL0xMvpi/yCPhB7uFxszX0oAbuvB5As6r73QwsvIAuGaNhqMgDWWnf5gQXO6j2whq5bFMlcLwecDzM+v0yAAAADZBnoZFFSwj/wAAFi54JhFw8Y6xjSSeVFPMZloglwBExccrN3bXudludUNBXwV9vadFAXJk8GEAAAAqAZ6ldEf/AAAirD58fmAF7gBzAEKRXuhATpZsMsYh+QrkT8isPsp6CUkwAAAAEwGep2pH/wAAIr8b2PnxnhQy58EAAAAcQZqsSahBbJlMCE///fEAAAMCjcpZ4IaocNI2LAAAABVBnspFFSwj/wAAFsCY6GQelNxeoeEAAAAQAZ7pdEf/AAAiwz+x66PxDwAAAA8BnutqR/8AAAMAA5+a9wsAAAA5QZrwSahBbJlMCFf//jhAAAEGet8uNLG5qEmzhD78zmf7euHrkiSwAvXHkFpQrrZU+/wNgx2/S9IJAAAAKkGfDkUVLCP/AAAWwJpC7dqy4Jrg0AJphAihGafmInSmCpHEZ38npW6qMAAAABoBny10R/8AACLAuatIqkavtooulz5NmznswAAAABwBny9qR/8AACLHMrw4iR9tCVk85wACdL3UpmCxAAAAJUGbNEmoQWyZTAhP//3xAAADAo3vNyEA0ZAVDA18lODQWHl4SoAAAAAYQZ9SRRUsI/8AABYlWlFTREAAXUyBvcyVAAAAEgGfcXRH/wAAIsM/seuk7Yp24QAAAA4Bn3NqR/8AAAMAAAMBqQAAAEZBm3hJqEFsmUwIV//+OEAAAQT7D6sAcv82WJQTEl6BjudkZC1Lr6ELYmo/ZefBYXk/ViC2s3mW93YlKx986F97qfoaHA7pAAAAMkGflkUVLCP/AAAWLqamrfkJUQ5SwATqfo8CpR0uoMkeKwGQwcni2rUKxkW/V7g0OZSoAAAAGAGftXRH/wAAIsM/vf0CWGtZAFXZvOa24AAAACsBn7dqR/8AACK/Gs573gZDfJJFOuABLFzqXP/Ys5fwtps4e3VVNNrKWVGBAAAAVEGbvEmoQWyZTAhP//3xAAADAo2+GDgEWa/dRC+etm/yQIP8uTQ+FSZF02RZN8JfiO8W3+jywZBZLXGYRuFC/S5Go4XkLoumhwJ/n4oCE1CxBGK1igAAACNBn9pFFSwj/wAAFi54JX8Nm8lic64CPAmsKBeAAXUmic6FRgAAACYBn/l0R/8AACLDQKqZ3HCAAuer5szt/457Wh2vWr1YoVS+bAFRgQAAABQBn/tqR/8AACK/G9p8rvg6DyKHgAAAADxBm+BJqEFsmUwIV//+OEAAAQWVonx6q9ezqBLOEkkhWy6ihHi1RIpE97GrZ1d0HywNOj02lYclnzrFkd0AAAAxQZ4eRRUsI/8AABYsTmzC2DKDr+mgAE6nyvYkkfnn809qyeOdLOmyCpRcb/N5CmclvQAAAB0Bnj10R/8AACK39gTykht/oX3q0DO9GMd+/I/vQAAAACwBnj9qR/8AACK/Gs573beNn2dAAtuq39Nyu4znzyInu2axxmogCAqm02xmPwAAAC5BmiRJqEFsmUwIT//98QAAAwKNvgySRZ8gfzQ38QAZQstCbhVaJ0IJgRUppw4LAAAAH0GeQkUVLCP/AAAWLE8euz66EULL1JUsNIzRw5AghsEAAAAoAZ5hdEf/AAADAdqH2kKpDgAXPVb724PcXRLO1YptvLVdxtZ2KT0jBQAAABMBnmNqR/8AACK/HFLZfpbtg3HAAAAAQ0GaaEmoQWyZTAhP//3xAAADAo2+IugCDzm0sIB4O8wmKw43517xoOZxCrSozg0ugevrNv01SAzrAVWGZW9NKcE3h4AAAAAYQZ6GRRUsI/8AABYwn3G+vB8aCXcspI6DAAAAEwGepXRH/wAAIj3VMQ6O/Gh/OggAAAATAZ6nakf/AAAisisIBqdBwUBvwQAAAFNBmqxJqEFsmUwIT//98QAAAwKN7zH1kvasUBFrGn0TU3razP/sVcxnAGPi1T8KvmHJnjuTkqfsCrzueHEXoj/mvHFc26wBDnt+t3R2B5FBvAS5wgAAACFBnspFFSwj/wAAFjBaE85fEzqusJBokATzbf1ZhlqgT4EAAAArAZ7pdEf/AAAiw0JXukUEYNWLgAC3AGDhuxERKO4m8/trWwTKFZarmzd/MQAAABQBnutqR/8AACK/HFLZfpbsm4QY0QAAAC9BmvBJqEFsmUwIV//+OEAAAQZ63y40dYQHerIWIBH4n1owoNYvwGnt9ClRaq7jFwAAACJBnw5FFSwj/wAAFiVWd0jQAP51FKIeejohxMNUc755nAdBAAAAGwGfLXRH/wAAIpMwbEXK6r7ISgAfVXzEyLSggAAAAB4Bny9qR/8AAA0vtohH3kAEqFUSqaLxFBEDRvOAAl8AAABVQZs0SahBbJlMCE///fEAAAMCjDof7ngA+Y7Kdjj5feE0vzOK4ZxZHlEu5H1lSgkk7Z8snrBpMc8MA8lQA29KjgPJJLbU01lvPYHVacTeWhS3qaA5GAAAACdBn1JFFSwj/wAAFiydeAK0DKdYzesnAIu1j7AAO0dQXKl0c3ysdMAAAAAcAZ9xdEf/AAAirD0dzHM/HY5lfrTxjlqA/xAhYQAAABMBn3NqR/8AACK/HFLZfpbtg3HBAAAAQkGbeEmoQWyZTAhX//44QAABBToHTAIEfajI3QB9o56dI/0sYyvgLt6IRYJUYejVh0wjXdBNdQEq09oUp/CyDbKVswAAAENBn5ZFFSwj/wAAFhqZLScAFrog8M/UReGWX7FryLgG9FoNIySXA+viuGpQbnyJrtcJLIg749MMs4nwlzHuWimqjnpgAAAAJwGftXRH/wAAIrf2Bjz1sU6qVFanVvPKSClRgoQUcQrYBX6AJr6/vQAAACoBn7dqR/8AACLHMrw4iR38lo9e4k6t55O5W3mChBP47yfeg/CKsT1Q3oEAAABIQZu8SahBbJlMCE///fEAAAMCjrUCU98TbkACWpUt5BjoORzv/Qsnoz/Y2ptcZScoyVVQuPztXpPQR6vkdJOnafyC6eEO2kdRAAAAH0Gf2kUVLCP/AAAWLEPNtxcSvhnAvUqTa2PDal1aVWAAAAAaAZ/5dEf/AAADAc+KU07eYlHKTgrON231JNkAAAAcAZ/7akf/AAAiscwQRig6AZIgKfQf+HHbHbwFfAAAAFtBm+BJqEFsmUwIT//98QAAAwKNvidvAKR4ud3yMEfG0BYK4xa7fYBkCkRDNs01jSCnBr2XUlm4hlwrH/4ZEyGg4XxmIBdLVUn28EcBbb3aJGaKd28V63yCQTrBAAAAIkGeHkUVLCP/AAAWMFoFgMvf38yW1wiGSdvxkJ+K1FBJcEEAAAAwAZ49dEf/AAAirDj+9JE5hhj82ABcMAu8GULBysJJAJbpTKZVaTBAwJIZNs6ujRJsAAAAEwGeP2pH/wAAIr8EK8Byi9RHY0EAAABHQZokSahBbJlMCE///fEAAAMCjxInnVwBmeRgxf4AwBGFI1Ri1s+FIJ8uR8ic8Xbqr7wvEKQ01QVx+ivNtZdoeqeFYtvrD2YAAAAqQZ5CRRUsI/8AABYYDsZOsw0WxsAJq6imco8/Q97xHrHqWbyQMyP/nofBAAAAFwGeYXRH/wAAIqnOxZQmNiqzGdp1J5qTAAAAJQGeY2pH/wAAIr8dLBkOJ8kAF1EuDhXbNJKGd6yusWSXHNQ3wyoAAABqQZpoSahBbJlMCFf//jhAAAEFOglqAd7fxFRGheszbeAoXxIeYrzXC8+nkCvAYpVo6kcUw6MxoPaIsFwetN7Wz4pIYnR/VYXvkCPLAjCYGQHIOBWjcESRMzMkHq2Adt9V3XezifUAAfCA5AAAAB9BnoZFFSwj/wAAFixDzbcVzKyZST/+WCi20f7kHUnTAAAAJgGepXRH/wAAAwBDV/C/dhoALWfRNMA406qCHELagHnUwobEGdvQAAAAFwGep2pH/wAAIrHMCW+EPUkb4ZxkIDAhAAAATkGarEmoQWyZTAhP//3xAAADAo0FYOAzVmqGwbLH+awyAVKCYAWWCx0VORRqYRcqWnDPhvJyCpCdb+5m5ons+vqllh1Bpg/6MvMJY3SNIAAAACFBnspFFSwj/wAAFjBaBYEjlG/KI2SJCbaTRkIjZf0XLekAAAAoAZ7pdEf/AAAirDydT8vwwcwAJY/XjF0IBBrwmv8obat3skqdpxaSbQAAABIBnutqR/8AAA00lSz3FAkAYUEAAABLQZrwSahBbJlMCE///fEAAAMCjb4YOA0Zd30mjO0pe1TiC5wX7B3S25ZOf1J2cl2diDXBt1LpcuqgbJVstdmfKQ3ibBPVBXzMg5H/AAAAHUGfDkUVLCP/AAAWJVwX3QJ9IXjQJ9ZrZFCfiSdMAAAAHgGfLXRH/wAAIsNCV7pFBGDRkhi5PZss7VySTdghYAAAAA4Bny9qR/8AAAMAAAMBqQAAAC9BmzRJqEFsmUwIT//98QAAAwKNBXmQHAE7aAcgsmOAIKifUFLESB+Ggxc6JGp0QAAAAB1Bn1JFFSwj/wAAFiUrN2taXriig8IwsDncx5qHTAAAACoBn3F0R/8AACLBFQcZnbhyOu4AJYp+dVrhtoL4W8GXMBsGRcJE3YL/OmEAAAAXAZ9zakf/AAADAAOi+TACZR2d7+7dwsEAAAA9QZt4SahBbJlMCE///fEAAAMCje33/isiH7PnKNlf4uFqRSeY6cbdxpO+FV76Xz+KjI551VWeJGmqK494QQAAAC9Bn5ZFFSwj/wAAFiUrN2taXriig8IwuuQyo6/YAAue415b62RbF5/0+Qvs6f5bggAAACUBn7V0R/8AACKsOP70kT0vqgAtRGZsM3zBUEOHXoW6b+A96L/TAAAAFwGft2pH/wAAAwAJ9nkMwUD1/vZB5z4RAAAAL0GbvEmoQWyZTAhP//3xAAADAo0FHUPUD+/r4zbgRp/uGXI67qVLyjaVOqxwD75TAAAAIEGf2kUVLCP/AAAWJSs3a1peuKKDwjC8Ataocbqygc3BAAAAJQGf+XRH/wAAIqv4W3gTKgABLVPCq3ZaYqDgldp08AkoStPOD0kAAAAmAZ/7akf/AAADAAn2XVpgAbUS0/5eoxlJrTgBNcLzCKm6YAn/oEAAAABAQZvgSahBbJlMCE///fEAAAMCje33/q6gf39dFSNTpii/zLcM9SZrLUmaHt7cOJVehPSNtIe54GF8XPmcl7IkeQAAAB9Bnh5FFSwj/wAAFiUrN2taXriig8Iwu3W5ttJwnncFAAAAIQGePXRH/wAAIqv4W3gKCHQAtFlY6GQD5+3jV9bS19Au4AAAABgBnj9qR/8AAAMACfZTPJEetI5ELKC58IEAAABCQZokSahBbJlMCE///fEAAAMCkcnc/El59ucP1+ADI8KpPnw7Uae9kwpZGtNQdeNt3DVwa0CJhKYnEv6QGm3KRG+4AAAAJkGeQkUVLCP/AAAWIyv78zoQSLeekkqzESB1tCOmyYhv1mpbMaPBAAAAJwGeYXRH/wAAIqwJIbaJV384EtUADjdCn64x8oIbLTvFjS0RBzqDfwAAACkBnmNqR/8AACK/BCcS0CzLr7WD8wwgAhS3N9Z17iQOGKi6W8bMg27egAAAAEpBmmhJqEFsmUwIT//98QAAAwJ7BXmQEzaBdEiko0BnbSiLYRbq+zmeBlsKTcD4WLHZETG4DmTq0kxClj84FGVM/HpXgMhtbpW84AAAADdBnoZFFSwj/wAAFaBaFcMlL5Awuy4tWw+/qL4WiZxT+FZ0WWocxeOc/TQV/LBeT+Hz6NHMfa3pAAAAJAGepXRH/wAAIaxCVCT/CvaXIBo33BKiBNRoPs0RrcaF98qBdwAAACsBnqdqR/8AACHHMrqbyUpkE4KeEsFMzVAAhrPvTm0Q4LAPXRHuhKcnPJ4JAAAATkGarEmoQWyZTAhP//3xAAADAnvt+YSmm4UqIqhDU9Pxvi0NDm65fyAUQU4Q5l8L9D4sAtUJe5UB5QJBZhGYSOhnLHiXAUXhTn1dYfa6wAAAACZBnspFFSwj/wAAFaBaElAH83l9KcP4ZAnppuxIIiW8wpUxT4cNBwAAABYBnul0R/8AACGsPR3ORiw2ae3QIJaRAAAAJwGe62pH/wAAIbIrBSTkf8ScGGZp05GAAe1nOlGr3Zvqo+0EZBX0HQAAAEVBmvBJqEFsmUwIT//98QAAAwJ69+abiIfgBApAUaBDaGvoO6f0U7PNDcDnSMgHoTqIF1ZYY7SD1TkjIGatnZJHkT98VMEAAAAxQZ8ORRUsI/8AABWTLI9+728B0WABNJ8rvwxfdgKa645DiEx+isU2R3kyDDPnzllyoAAAAB8Bny10R/8AACGsNxOEoRYM0V8IpaDPiEatuOOwIAmYAAAAMwGfL2pH/wAAIb8azB+ZS0/XOpABaMt94Mr4ABwVpDETJdBEB9DqLDxoRllZkjldAgYdMQAAAExBmzRJqEFsmUwIT//98QAAAwJ7BTSo/YMrlMq+AFvGeabtrTzoOH+DYgALhbXTEbmAc/TxIvqz3dXvkFdG8U9ucoQBJQAA6dHRqy6WAAAAOkGfUkUVLCP/AAAVnE4BnYuMz5HWAD9tF1O7xVhv+iE4r4ik7To3NjDavHOVFYUwV8zixJ92rmb3AiMAAAAfAZ9xdEf/AAAM3gDSre8yb9sQSE0xjqAq4+uuTyQqSQAAADsBn3NqR/8AACGyK3eAAS1TqWocb4guMvv1FIE1cysg9b2KPn2z5xxA0rixwifG3cED6Fz62DlCjgwUEQAAAIZBm3hJqEFsmUwIT//98QAAAwJ8rMCnelBIQe0tkAC1SAMDsW26q0hDLPaRaz43oldFMNUTr722tjzDKqdomk+csUd6w3dG/9eq6HMr8m0+KnkATW7Ca9bAakJsqAHl5mJUrZM3CMLVKMwY1UZ4RGKF6d3kVRg7ghLQsEG0En+EOmg3wqh4cQAAAFZBn5ZFFSwj/wAAFZuUWDyf/UBjNz2sQQgQVxcacZ/J5O9d9d21eWZYLu8t5Jmecs+S0W+x31k0Ez7hQZRNoIax83dYRotzWePYzCOK0RP5uleh5FfuOAAAACYBn7V0R/8AACG39fv6hCyhuVzcVyY31R5279acuSCDiUY4pH7KgAAAAD4Bn7dqR/8AACGxzBEQGgAtWEPCVYqE7mwrNsay8Z7Gqrdy5Oj/byuHbTIBCY4dlUExxvtQYkkEs5/F6S4URwAAAGpBm7xJqEFsmUwIT//98QAAAwJ699tMVGpMMsDR5IhXshCSLa4sEHWTUUGDgxUw0ATZImfn01PSSVmskdhW8HtZqSd0f1y+iK+REjvD9HpGaSJ30xu1SZ1o3dT8jfzvqq+I9PKEUPWnWK1wAAAAO0Gf2kUVLCP/AAAVkyu1AlkrzwgMpSzyQtXkzEba46JEABgfRtV/ntuKfAeT849TV9Ekzc/MiukieW0YAAAANwGf+XRH/wAAIawJIb92GgAtWEIBurjyetzJ3+kgcpg3V0yvlmUpppOJAONx+yqT6ce/B/wNebMAAAA+AZ/7akf/AAAh1SEAHFKw+Q7aTs2EzaGPdOHyyHf85Vky0ea6F6QMNgR8L450hjtK1mM/VfT44vIP+lid7YAAAABQQZvgSahBbJlMCE///fEAAAMCevgEfAUM6niI5AIfxO8BAe51s9NmNq0o4oHJmcpI7RTowWLB/Ryvsv7G/LF+ix4fODG1bdk+S/+A9BqPkoUAAAA6QZ4eRRUsI/8AABWblDcjOBj5hHP7WA2gkxoPxDDNcOIgGhIuIs26Q8lblY47Tq0O1rp6+mml0ZEIFwAAAFwBnj10R/8AACG3x2dAofsqK9gUAFqJfSkgb3g4tSRB/Dbl7gK9WxjKtoJ3Hh+NvIgb8+WPLNvBGHVFjbxkNCho7hMQ9BuZGJPHeP3IET51Ltqykn4cBQLQKQ65IAAAADQBnj9qR/8AACGuMeJ1p3riTOOeABaMuAd4DvcX+WBV5/BJ2FL9ngcrE182sDogqETlDW8nAAAAQ0GaJEmoQWyZTAhP//3xAAADAnr33k2hy/P+eC+bIzmWv92XXtIbhOkMwQANSd4A45acnGOnZByWJnZianE8dwnsFS4AAAAoQZ5CRRUsI/8AABWTK7UF3mpCH8bO/OYIs4+L5v2t+6SQaNmT5uD5MQAAACUBnmF0R/8AACHDF2QokOkE83vURMP+s7r6nFCaovd3M54/ov3HAAAAJgGeY2pH/wAAIb8EJm4j4S22h885x/ErBsWP1XLJhEW5IgQlxRiwAAAAkkGaaEmoQWyZTAhH//3hAAADA99j13OWkR1pv8BUd0IAu/blZhNX5gF5Q/D4gQkqr6DY9ImIsDhvgZE2Zw12d0bFySXCLSHV7UV0O8J1JY/JuShQhP5P00//2Yyc9fZtI7liMWRd6NkBxFwhnRugr0i1lZCPWR05eJzqtawP+0UxuTItDAX/kAmzGosLS82+cs+AAAAANUGehkUVLCP/AAAVneBWhrVAERp6Gu98ilkkeNr2UX8vmPCIOJfJoP4PGkz8hzPBEEebD/8nAAAAMQGepXRH/wAAIcMXYzKzyFd8p2gAW8AhGN9FEs12id7hsbuGms0IdeXUg4WrGQLiTyQAAAApAZ6nakf/AAAhsehhdAhBm49INGucTi346Ukx7tz8UBH/cqSihwlE7YEAAABhQZqrSahBbJlMCE///fEAAAMCewUb0pMsAMyS8N4TawB7K8Yxo1hIGV6H+CXbeaVmJHCmE07W9TabOk6EsVKNmR72Ot3b/rjjrdgG3aI2H+W1OlsrbjBTO0mcvNMhVRtsSQAAADxBnslFFSwj/wAAFZw9Gt1ErijAn5bWwubAkLIARkXGotG9WFwmEMq9aH23H5Hm/Y5YGr+IL376HuzeUYEAAAA9AZ7qakf/AAAhsYWgQT4/EJ0+ABVnqfp5dwP5eTXYoWrUVUz+8xSaNYMpqV0DuOmAjrnjk606pnz4Aw5xUwAAAG1Bmu9JqEFsmUwIT//98QAAAwJ/yfWZG47aFZuikiXCzjQndyw4AF0C89n8IbGJuPdlFJuUMXZ131wkWrPphSUY0OsG7Fkj4krDJYgfoeDXc/odz59k1foZOLz+ilQk/eV7048Fpl4/LBrGqS13AAAARkGfDUUVLCP/AAAVlSbjmZeFtxEJRxOSqP17ma3gATbTn8sJheth1khnSLh7DakNRzhc5eEipDBsKrJMIEuySeMzbN1Kfq0AAABJAZ8sdEf/AAAhrDkCyoedhzfABbgBrntjaxMd48C/V8dEyFAJeg6WSGNnzrR+Utuw/6DGc4ccnqbKKWH3JK35iuPFWXzxxEx0wAAAAEQBny5qR/8AACCyLepnweYHAAueq3zUgNTmwSDEmqWqrxya0DQVPrPM1NAc4ZZ2t0HMfk0XdkH7kCLk6UubTN/sQhxasAAAAExBmzNJqEFsmUwIT//98QAAAwJpxGaakiRHVzGbgkh+KDS/2HM5eBnoduF2Gvq3VwaAY+z+D6qkwza6iXOxDI8MHRYHM+P1OCzRAMEbAAAAVEGfUUUVLCP/AAAVAyxqB/BHK5es08g5ykto2rzmPoD6jKZSc+VdxZ2uba5hknsMypGRW3F++3T9MXZKxn3UmQ62rgd/EHDqCt1Jupmtl08pLl6emAAAAEEBn3B0R/8AACCsNt+qxwfAAuf3b9P6cT8T/hfVtx66f50Mn0ytmHaD7GlyNeQchJW6gs3U5cUQch2ZSaro7WxkfAAAADABn3JqR/8AAAyFnvy5Wq213eB5EkioALhhCY77oC+7Ye2l5QN4jkiiy8WK0MT9umEAAABJQZt3SahBbJlMCE///fEAAAMCacSEfANSoQhGLV4SGU6qFA00i4/YmcRC3NgdoxHR7xIG0GSBpmEBAgUc7qk2tEGNEYVE16Nv8QAAAE5Bn5VFFSwj/wAAFQuUkesSJo9cNzIAPyDWauCDAKhypfqaZzUNLXd7qb0IcN2Ad2DB0DZsSYASH7v+S9HqYITf3sQ3LgxuBQFeUhaX82EAAAAyAZ+0dEf/AAAgt/X8BB738AKgBaz/BogFoig8ZvMGfudCI3dS8QB2YmfLGIyf7tsE7KAAAAAsAZ+2akf/AAAgsiXaNFXvqwY1jIsABcMIe4BkfKmV4MhCArqBVmW1sDDOVYAAAABJQZu7SahBbJlMCE///fEAAAMCacR+wATj4+ku1vswJFVZB3++h6zlRyJdVkcPZ1w2AQJXLcloaoDn96Q2yQ0fL1HpWvjcm30TQQAAAEBBn9lFFSwj/wAAFQuUWDNUddZCXNogOzaAKk++bOLA/xwawrKDgxxK8AipgSbXHmLcm9N+DI8538dDz6P1aumAAAAAKgGf+HRH/wAAIL0ETICPrrgZnFv9hn+JWeAAuJ/XL8mH4jLq/5f5ivqidgAAACkBn/pqR/8AACCSu6kSuKnHsdAFahn+yR80HgtbmBvYP+F++2LC8XuBHwAAAEFBm/9JqEFsmUwIT//98QAAAwJqXP+wAT/oKoxQEsKlIBv5vmqrtM1kUpl4ZTZUGK6FhaTw2aAcRTc5RJyfLHtxUAAAADdBnh1FFSwj/wAAFPgOxk6zC4EjVtQBuDM2dNZboThirgdLJH6rNFhJ9iivl4tO+CF+RhqrmDXTAAAAMwGePHRH/wAAILf1zofAWHpwYABdRLh+wveP82XdPS+Sz8RORjtMdZdEEY+IJs/adInLFwAAACABnj5qR/8AAAS34IT7jbl8CX/KgoLE+uVtgNRWxrp5sAAAAGFBmiNJqEFsmUwIT//98QAAAwJpKLfrNu8BQzpmoGUdhc6gIETfkPU5Q5K+ts5j9esvchJO0UwV89ICcY+9zuH79vZtNLHkbpVnTAkNjIlemoeYb71kXhDEjZJGBQvg0IGBAAAAIkGeQUUVLCP/AAAVAyu1BbkcMATC7xKWnHRofXFbZzAMeUAAAAAfAZ5gdEf/AAAgwLjfw65DvdCIVHi4Xgcsr7fddvlyswAAACYBnmJqR/8AACC50ZiAEZErZ3PnmqrvqGgL4DmPGqvHjKvlBAd0wQAAADNBmmdJqEFsmUwIT//98QAAAwJpz1HXQhM7OKYho97Y4y2lypSFgAGuMNPc3wP4dk7OHmAAAAAfQZ6FRRUsI/8AABUFKzdrWl9sfTNzdPssS4PXwHm8qwAAABMBnqR0R/8AACDDF2ippVTfAE3BAAAAGgGepmpH/wAAAwHEyVGG5Qa4yERp3pK5zHpgAAAAQ0Gaq0moQWyZTAhP//3xAAADAmnEXlUXwCjlbbWkBPvIiSP/Rb1I26D05vfyW2ZqAtTFJnPTvOmCEeYDGEhU1RBq5GsAAAAxQZ7JRRUsI/8AABUDK/vzX6ZqRJoqHhz+ACdYSVI09WTzRLqyOK3fPitvODQA9YcumAAAACEBnuh0R/8AACCr+FflNwALURmbBPEzQsRmSP+0VN0A8IEAAAAeAZ7qakf/AAAgvwQnEtBhUYz2JzjNSTeT9JWa1PNhAAAAX0Ga70moQWyZTAhP//3xAAADAmnPURgeW/oAaaPXopYIj3mSDHGnGGRV0RMrGyHodtbbcK3zx+Xn4WAatRXLJE13F9WqkM8yx3MGKj1FKqEkA3mtpsblLNcHHKZx7RGhAAAAMkGfDUUVLCP/AAAVDEbiTFUApO0vegLUA+EEAJliUE7sxUhPoPh8lyqZ3PNSmKPwKMenAAAAJQGfLHRH/wAAH8sefGJm/QheaxABdRKz3LLvI5bPP8uploeyzDwAAAA6AZ8uakf/AAAgsf2xIJ38/GsIDZCx3PJId1fotTSWkGKFEagQAta0s7Mrmc2M5BPmsUIkH/r7Za1JVgAAAFRBmzNJqEFsmUwIT//98QAAAwJp0LuN0evQbwIA27tdLHMwGAug1ZkTbv5Ur5p7VhUfXAe0xAwNU8O+QfIL+OlsMMmq47aWjglq41/JZ6EnKIQwh3EAAAApQZ9RRRUsI/8AABUMRuJMVxkG0pWencBdbSgkP7rrmLIBbUqjAuUcxdMAAAAYAZ9wdEf/AAADABh8AbJdoK8cj1NwoumAAAAAKAGfcmpH/wAAIL2WAorVkuAiVABtlafpYA33jMRIFFXhyvZIJbJP8q0AAABBQZt3SahBbJlMCE///fEAAAMCbdE1vz7j7/GCWYOmc38GtnYxfLWDZ1EgzeuE2ATj0JX/b916+M0KNylbubZ7O4EAAAArQZ+VRRUsI/8AABUFN6+KoAiVuSzjcrDMKZoZ5oALV+jhc3dXOGAH5HpiPwAAACwBn7R0R/8AACDDF2ippVPU9qT0BDtiAgBbdVwDOFrMYaZLEJ5FPOhK7Dv0wAAAABQBn7ZqR/8AAB/OfAJUKLvosvnFNwAAAD5Bm7lJqEFsmUwUTCP//eEAAAMDtIP9HQsydingiKJmef50QYzHGiLRsuE5Cyj/wsAXAodfnNRsWN34sN6mSQAAAB0Bn9hqR/8AAB+81GmJnHDUekPIFvuQ2BXiCpFPmwAAAbNliIQAM//+9uy+BTX9n9CXESzF2kpwPiqkgIB3NMAAAAMBVQAAAwAFV3gC4A3AQVycAAADA1AAoIWAR4SoWwkI+xy0B8t/liBHCOATilIaMn0XDABCvDv3BDGws2U7BJL0/lLxgChzqnPiRQY57VTI7kbLJUNwqr1I50c0+cfdQBWv80VtuuW01oHvMtDMHnxe4Ab2txw+Qe5FOJYnIMv3pnn1FIOakf1gCE3I9cLCKWgCG8cA5Q00vsa/Hb67VBAY+DVUnEy+wPSG7DrW3a1GOX21HWpMUiZZIpR/28fmWhYX6fb8dqThBlYeydTsO1YeFFLfeyPTR9BQn8HnbU4WHUzNoRfJuUQOCzF/4jEf0NaXWNMD5iW1y9+Dy8QCOi//vSDsFrAou37jjbI1bkKNJ09tbIxwRv1yizmiYuumtwFZvNaw8DdXD4Cww+yVGYBROfJOHaF8an7NI6XWfCAag81d/FB1kkbWWagLtVu8fSNtuTffSzC2JuIWHTmqyHdghpSkAQVEBnaCPd4w4SuWjfU+E+Rck0iD6aF3/oq1ln1Ki0T2NEOLANgAAAMAAAMACAgAAABMQZokbEJ//fEAAAMCWhIfOjBfDEmfgQAhNcWb/JHHRgtVuWIEmyhD26FlBRMaokDIxLCFUv3J5nlO9wkfpvl6b4kbGb9C/4GtAaWACQAAADZBnkJ4hH8AABR1WR2dwAxkxCIQ0gvBlB+L/yySfVRZX+o9qZLtR/C1ZGTNn6nMdi5LIr4r9EYAAAAgAZ5hdEf/AAAfyxdPc0rO0rHaze8AIrur/B0P3Gnk4jEAAAAmAZ5jakf/AAAMRJUs+HSWhyESAC56vm3ecSx/lojSfRMGoT2RytkAAABRQZpoSahBaJlMCE///fEAAAMCWcSEfAJoV/RlJ/wivwU8o36sbGlXz47EoyEWwZT/ZaGGLVMAyA9Q1zDsdHHTiKZVBHhAw/JZfYIWzMr4AjtIAAAAIkGehkURLCP/AAAUe5SQEd2NeSYJUuCbMw8KGi0NNagEDbEAAAAfAZ6ldEf/AAAfwbanXIBxEZJpQLVW5a63DVltmGIBtgAAABQBnqdqR/8AAB+81GmJnHDUEeBIwQAAAFlBmqxJqEFsmUwIT//98QAAAwJbK4lluubgGpNNAZbiqzD6b+1zo3CgzgUXy6NZGHtgqScRIN5HamW4GgshFAJu5rlgjA4tjdb7tB062vdgYiB0ZvPaV6dcLQAAAB9BnspFFSwj/wAAFHxObMLYTFd54Nfdz20ye7/B8Wu6AAAAHAGe6XRH/wAAH8G2qtIxVFguHxA8bfgxgyXolmAAAAAXAZ7rakf/AAAfvNRpiZz/NEUIbizc+EEAAAA7QZrwSahBbJlMCE///fEAAAMCWc9d5JmslDuEf6hqxScoCFbrss96Cp0u5y9Lj7o/F/6hnzbLTR6/KSwAAAAcQZ8ORRUsI/8AABR1WFWKzj/YoQ5RJupxW34kpQAAACgBny10R/8AAB+4ofm6AC6gELfa8Sxz2KWlaKtz6ElNlWpYgvlWK/dAAAAAIQGfL2pH/wAAAwADXknocEAE7dCnxTbhVoqYYN1LkbZUwQAAAEVBmzRJqEFsmUwIT//98QAAAwJbJAl6aAhNwCEniZsTi7m1+1cXKGYFTirMgZwcumQOAH4x3xiLmARoyMiOlOi3hT+KIEEAAAA2QZ9SRRUsI/8AABRnygcdG82fbfvVuawpXWlsQEAIU6kyE3w1Lu3zSGdCqWqYJSZGsB6eMXdBAAAAJwGfcXRH/wAAH8G2ZxK8a0LhNqgtrABasIeEqWkpyJHb+OEYpoB8wQAAAC0Bn3NqR/8AAB+8lQ++EwAJULCBiyF3WmbsDbPj6EYDJb6/hiy8L7mFpVfb7ugAAABPQZt4SahBbJlMCE///fEAAAMCWlz2+NC2opagBjQE05AKsmd8daOvu5HekB2h6rZBeQbDZizWsOxxx058W/NSDwe8f5V32e0Ua00nGOgAIAAAAENBn5ZFFSwj/wAAFHuUPlLA0cAJapFkacydb4nQ06tS93gLc3tCXFQq6f0mx7kNGBJJ6AfFLCMBC6uIy5tpRggFVO3dAAAAHgGftXRH/wAAH8G2feD6CNWu8axSZmcmAG8hmKbhBwAAAC0Bn7dqR/8AAB/H/K51HVh7EC8J2/wQUSfmmgA/ml5Q3rgdQHEF4i4zrzn5dsAAAAA8QZu8SahBbJlMCE///fEAAAMCWlz27UwbUXp0OA6a8NAK0pBgOKGVJO7HWyfETcCaQMRczR8LohGQiIXxAAAAMUGf2kUVLCP/AAAUcyu1As28IAjcchjvWO4nfPYzQk4CM7ZfF6SQJnsdMfjBdqWm0SkAAAAhAZ/5dEf/AAAfyvjyqaVT2lIr5HLQpgjTA9qvmOuxflmBAAAALQGf+2pH/wAAH85752oS3mBX5HyJYAFz1XAM2mAsQTGqVvk14c6JtEHBSIh7ugAAAEJBm+BJqEFsmUwIT//98QAAAwJaiZ3PgImXOi6sKrJK/LjvUUSBjNo8NMKZqKaoaQtGxIMj98quSIsZTCrsFLBfCuAAAAAxQZ4eRRUsI/8AABRzLAOePe0bBmJTitWo1vZQgAe3P/Tc9/RJNUlsziE5ptecZl90swAAACYBnj10R/8AAB/LHmxiZv0IXmsQAXPVb724E46KMvUWeEmd1SQeEAAAADABnj9qR/8AAB+8lRhuPdu4AFqJiRAQCKW2XYjV/NwVyls3ThIpTM7WA0UXWxd5PaAAAABKQZokSahBbJlMCE///fEAAAMCWcRgK8RbwFJG4ksrF0PF5sDjO4zpd7DL4aX+CAQPtj+y1TDLUUWf81XbdXuC6gf/53pPR2z5IE8AAAAvQZ5CRRUsI/8AABR7lFSxjWMe4gWgAOzwATt1FJ9hDE1c+cTiIuFQ0oATcd4es9oAAAAVAZ5hdEf/AAAfyvjyqaVT1PvIKAetAAAAHQGeY2pH/wAAH8fpbJ8pabNo3F3sTKd9BWauv6yzAAAATEGaaEmoQWyZTAhP//3xAAADAlnPUPXZQkHd0pHMiWRat5SolgiomOSh6eADgyIGc6a+Olc2PFF2RiRBQBFbIgZ+ETvCv2zhuUTPGYQAAAAsQZ6GRRUsI/8AABR8PRrjW+NcQ9lIWCcPBT5Q6eGuxNA/zFHKgvDRwA37+jEAAAAcAZ6ldEf/AAAfGx58Ymb9CR1RI97vq40BWn4ntAAAACgBnqdqR/8AAB+8tv+D9hBmMewARkS0/XHALkiWSo/ZhVqHUdRNwRZRAAAAUUGarEmoQWyZTAhP//3xAAADAl3RNZkbj8BlgDIgXeiiL5LOJz1QlN5wAbPjeMd8Ex3a+1LiWONVAmHeUMKT6Z6sGTbp+ye93rD5zDVxMkXCkQAAAD9BnspFFSwj/wAAFHU+0Il27iLDUYBKWUQuhbX45Lonm0Ck1SeBtGhMC9+9UEx7B1/xcnm3QcnNXdIhBRn+12wAAAAqAZ7pdEf/AAAfuH2mwhK+vIALD2j+qlrLV603bJyJCbfLDfMLVLpQCPaAAAAALwGe62pH/wAAHwmoCRoHSkR8BHpOOnp36kiKHCBUNoFFDiDaumHIXfDI2cl2k8sxAAAASEGa8EmoQWyZTAhP//3xAAADAknPX2Ap1YDuGftsj3FoaHPLMqGH2/90eDhdWsYAH948u3R+gDXp5VvUeVm85WqJl6OlgpFLwAAAAEBBnw5FFSwj/wAAE/BGkb8yMyAD6yC8pA536f++Xv6SdoEPn3R3ZlrSpXhl2++7Wz/3qdS7NgTC205ELw+YQCUhAAAANgGfLXRH/wAAHxsbDxk0haH1BuHj5nwq80dK50S7jWDAA9rOdKNXzMocaPAJj/7oJ7ZqYAii9AAAABkBny9qR/8AAB8M2lhXNcaWTqjPbSufF6C9AAAAXkGbNEmoQWyZTAhP//3xAAADAkskVUlWZeASaR4hc3vZi7Z2FqmsuZeSxwCEUie90YD/EuUgpThNaE01AhsPBgybIY+kePUqqVXlaoKkJ/pC0KHP5VdstqeRcr1GKGEAAAAjQZ9SRRUsI/8AABPrlJASKnAtgyKivGibCsvu6tD3SAg+iBcAAAApAZ9xdEf/AAAfCKHmSx8f0FHpABaMt94Mr4ABwVfMspDptuVktLWzpoEAAAAaAZ9zakf/AAAfDNRpiZxw1BOQ19AWsoKYgXAAAAA8QZt4SahBbJlMCE///fEAAAMCSonzXlFMJAaeJKVDFfQANipD03W5CethZB/IW6i8KnamVFVuffllnhcgAAAAKEGflkUVLCP/AAAT4yyLxLUbyBDA+t89MWMo/XtNEOqhbpenfOkxXpEAAAAnAZ+1dEf/AAAfCKHljGvFyNjaAC6ge3gpOIl3lMLxrGBDCaWuOzLsAAAAFAGft2pH/wAAHwzUagTPVGyWaGLAAAAARUGbvEmoQWyZTAhP//3xAAADAkskCXpoDMniEpoltDciYnGs9mVDwVO3r93we0AxHlhltqjixRAPFrRxpi9HsOuab1qBgQAAAENBn9pFFSwj/wAAE+uUNyMJxNMIEmqkURv44qAPjILFFQAhTqSYsPV2sRkkNRlRTe0AnduR5/EEakIuKyifHGM1fBjhAAAAIgGf+XRH/wAAHxr48qmlU9T7xY1STlP3RSBV0+JSupJo+UEAAAAdAZ/7akf/AAAfF+lsnylpt7pp917hg8QN9Wvl29IAAABAQZvgSahBbJlMCE///fEAAAMCScReTaSWyCZJLABMoYedBttWo5vH/kruOyl4wQ2isqWIybhSW68BDDlYQhQDoAAAADRBnh5FFSwj/wAAE/BGigR9Le3GIzWuyjHwY3Y7gIdeVYn6nrY74WYwA425gmfdkkY/WfKBAAAAHwGePXRH/wAAHwbpB34mxDWbyPtA5x0rYWYZstjLS7AAAAAfAZ4/akf/AAAfF+lsnykyv/bXrQzWMcJ413yJYrR6sAAAAD9BmiRJqEFsmUwIT//98QAAAwJJxF5NoezzgAkg80bsQPFKcfl5MIfNuMAYBWDY+YFkBr/BWxxS1vshSULhLw0AAAAjQZ5CRRUsI/8AABPjK7UGANZFa8Xtl1OrCIFRSkzxTX1ed6sAAAAnAZ5hdEf/AAAfGvjyqZ3xxWW/RX8CQASwcb+9Szs+CvRvbAikTwM/AAAALQGeY2pH/wAAHmgBL44EnxAGCodu4ALnq+dVo7nPsdwUE+eSTQhvmYiYZsb0gQAAAD9BmmhJqEFsmUwIT//98QAAAwJJxF5NoYmQT3LoACx4vG9ohLjjt4zL2CBp2UKz+oYxtErO73cIEtZJ3UemtYAAAABIQZ6GRRUsI/8AABPjK7UGRo67gBNXUp465tJJugpQVtBS/XRnq+P4NPKiWRwpyb8mXJhZBZMqgdU49mbxjxaFb+tPq0RaHqvTAAAAKQGepXRH/wAAHxr43IP6Y814gZwYOFAAXQAwcNg/5Y3LRT13gNoqaQesAAAAJAGep2pH/wAAHxfpajEX4psAoIpsiVV9LFmET/kqnUheMBZdgQAAAFtBmqxJqEFsmUwIT//98QAAAwJN0SGcjcEf26XsJKiBVRHsdWZK3+DcGenUPMEqFxN5UarnVYF7jpPeML7c2+MXj7LdTO3ztDXVc4FiW+jLanBeoODWIXQxhA2ZAAAANEGeykUVLCP/AAAT4yu1ArX8eZqJET142y3+dB+QALilP8gbWAdkoj9HYWAjDDcWvSrOr0gAAAA+AZ7pdEf/AAAfGvjsrx+otACWU75n/LmW0Gm4AYCAXqfL+yXHUdycYaUKfaUeC7qRm6uBZXz2hOUvyQNVSqYAAAAuAZ7rakf/AAAfF5NYHSrwYGk5xEAIyAQvG+jWLNp1Pm2Ihx0xhKosQQX8qsjL0wAAAGZBmvBJqEFsmUwIR//94QAAAwOHTZ8Q91XnKwAlfAMv2O2gSifRHLboR6sWwoXKMGd2twVrXxZ3+fz9KBcxfjFccKdNwiAIQ0t0512Ub1B+8/s/i2YTH8ec6ugBNpsOyBDIcdeUKV8AAAApQZ8ORRUsI/8AABNdlJ6OYaVUSK62MVGMy9Z/owmL24ItoIuDpgEc7ykAAAA2AZ8tdEf/AAAeayJS4UP6gqWQG+1KABFVpkthiGOd9jWQH9VoHbnES1hFi2wwKhB4CX8HlLNAAAAAKwGfL2pH/wAAHmf9V3tv6DPuVQHQALcAM+FGTxBRjIyxVKYZRc+sKOOvNY8AAABbQZs0SahBbJlMCE///fEAAAMCOonzXsj5kWSpA9odteU5UhhQDeKwV9qiRaU3YXxr6AKqyesCCYtApJSlo8RMGqijjXYmwsh79EJd7vbmIoVSyR9OsTalIipJoQAAAEhBn1JFFSwj/wAAE1aNoPlPGssZofMSgBLD0cNH7sydNuqqvjxvt1nzziHHV65HDfhCkjUCy0ntZfaXMCw8szjJyzyXRqdKT5UAAAA0AZ9xdEf/AAAeVumEftFmOWzBO5Vx7SqzkXwAlim4BnC9TnBYu+TL5iwtzDac+qP6kVMPuQAAADMBn3NqR/8AAB5c0SaZYAWQjM2Gu9hDklhHy9F2XEmqGoR1nlwlXGgJ1ctTyDCKVFCFLOAAAAB/QZt4SahBbJlMCE///fEAAAMCOxuffNMAIQ8aqDDLYcnype/ZNxgCV3eY8fHJinVPT7X2YQwZtBXqXR+DUbI19oSQaG9s5E2flkB3/2LNRgy7rT9hZN7MCHVX/l1nJ8XPTpc7Mka4QN5OekNuqJt6RhvvYHIHDWsJrvYOrqHvgAAAAEhBn5ZFFSwj/wAAE12UWDyfjvWBsL03yOVrPVzUQAmrqU8d8k3QUtvuIz1Dwf+A8YAIgMapfLS+miu/omYd5N2QEMYJHE625IEAAAA8AZ+1dEf/AAAeWJ2QIgBKm3scUBkmijTObQPFilV5BCh64kKhdTX1niZapcWGC80EZ7OJIETkEW4wtSGAAAAAOwGft2pH/wAAHmbAaKPSwCn7gASmtcfT/9//31IRVsYZtgit9OU02V7h5P1zRS8aEqQklp1nT0G8sr2YAAAARkGbvEmoQWyZTAhH//3hAAADA4hGy2uwuH04RFnoMc8AEzUANTlOPPdIxrxHtBetVWrboPqN7mRooBsGp2ZTpYi2ONYC7EkAAABgQZ/aRRUsI/8AABNWjPuRCnjyA9mtvG3bDsSHbbvn0YvaJjLWRSsg9RTN7bvX6Ce9z35gPObf0EFK+/9nbkfyEGbau1sf/89b+Hwp2bFGfTqaeLiZvmTJbQan0rD9HDvnAAAAHwGf+XRH/wAAHlboevryQZQ7DilEw5aJXLduVr+D6ssAAAA+AZ/7akf/AAAdrN8ZzePFgR8Y4xWI4nxAAuolwcMTE/ud47CDVs0hGdDxAgE48FdOGnscDginXoboFPQ78wwAAABwQZvgSahBbJlMCE///fEAAAMCObhcddDmQKoAiQq7aQ3hyUH48BEK/XSMc/4/aOLXIwKImV3ZzhIvgoRudk8OzdTaxpCIYmoReygOgjKrAsi2HqyL7zYo3mucrjBvmhcjfDR2/dRZQ3rPTb6kSF9YgAAAAERBnh5FFSwj/wAAE110RZmWrmUaSWMaSFzaC2gSwl4XbVCN2bUyvvZ9DUZG9WM4OCHWpdDw/LJ7aEdikEzPiNwAIwGn2wAAADIBnj10R/8AAB5oylkTdU4AFznm/vWv6Je/fYaR/pTqtM5pP0BRZ7zp4Uazhd5EXk+r2gAAADYBnj9qR/8AAB5Zpn9SMvSCTX4rJ9zR06rp/GfXbwAuer5szqLNBz53NWsbefjU/HQ08QN37MAAAABdQZokSahBbJlMCE///fEAAAMCObhbPJbIlndyABcOUOjE+2VC2eYzh3UK32Iyeow0JpxanXWOdHvBI6OS/myb4nDPKTq2wojnjvyGePKWpWM4vM01H2+SCDpBeym3AAAAM0GeQkUVLCP/AAATXZQ1XeM/BBmzMyw4BKh/he2ibjfP+cCAUto03OxsRuDSaGestWgN8wAAADkBnmF0R/8AAB5q+OyvH5IMJsz3a3lbTf2kAEtM+XIrdlPEE5e2Oj/lL373wqWHa9f756Zj6N0EH2kAAAAzAZ5jakf/AAAeWaZ/UjLG+/2BpoR4FkzWNy+QAlqnhVcHATWhNeLiWU7W1cPoAjhWnvmBAAAAXEGaaEmoQWyZTAhP//3xAAADAj3RNZYfIWAQjy22tGI0HKYsfF/f/Us8IXDQXSWyC8beSkmoqPUa5eZXCdKZrIN5VDznVC6PYliAmyP/vgaEbUmRf//SqrJdIVWAAAAAT0GehkUVLCP/AAATV/8IuJ8Q/VCgA+Yam56ieBb5yxyvM6njLRJ0/q6RL8ql5ydjOq3ik5bb+1h86qXiAnkBDSoffOeD4TnPvPR5VzpoB9sAAAA9AZ6ldEf/AAAeavjsrx+Sf1iIIjA8AQ8/S6WALD9oqEkgowJYuLUXS7bOs+m+sGuFYLg0e11eQixQvnt8wAAAAD4BnqdqR/8AAB22wOYtAYdCACR1vpFygLhPZnegXQZUdbzTD1uBxzE59gKC/bEnJNMPvczlwIzkWGELMMaYYQAAAGlBmqxJqEFsmUwIT//98QAAAwIpuF/wvgEDaInb0ADYsJkiwd/e+sigUQg85NUGcGXwjpPINPBIQwec03H+vuzjzI+ckqH9iWl0wkUIFV805jaNUFtfF1HoIB4XXHck+89QRbHCFg0BXXkAAABGQZ7KRRUsI/8AABLiMYLQyUEYpih2h1oAaQWXQwzGBft6JR5qfunCGDzJGmTqdPrszyi+2iXAVxbo0S2vJc/Aa7WDTHsLVAAAADEBnul0R/8AAB2m6aFRXSFh3OCMRPPXaRWUoALnq+BO9oPa7tsSJKG5jP4zGj3fYA0wAAAALAGe62pH/wAAHbbAz/BzwP/gq3XOKc0Vs6TWtZgusx9tgAe/G0x89QWz1X2ZAAAAeUGa8EmoQWyZTAhH//3hAAADA3QGSn1LzwERG28dNjJ4t9zuL5lc4rsIJDymxOdEO5CUbXBi6J0mQu2HwPwbYdN6F82T+8644YzVjzY0l6uU1RcqMX8PjMl6A+8jyjG7hLhiqsftwcPqUlNgL7Vr4UpY6soj6V7M+mgAAABoQZ8ORRUsI/8AABLdagxIAW5+PFNClMupUnJgMIIERQUnmNduhsV5UXQqvx9D0Ic5OBUFOuDJXh0wzx/K3OFFOqeTTzKcDeA7MCplcPU6s7WUM82D+9VcVnisOZGJ3/12fzFX+aK6448AAAAzAZ8tdEf/AAAdVOMUPaeKjsLMORQAFxP5eStZlou2ZMGTwkky+MEGmZWqJNpxgCKaeyvHAAAANwGfL2pH/wAAHZbAFtOiqbJ/Ya9cSZX2Pj966Y/gjUCzULkP3Xo29KZ2aX9FLwGtZ9B6lDoMr3cAAABkQZs0SahBbJlMCE///fEAAAMCKbvcddC+5X/SKS3sGDQrrvCdTz4cAFCaRNxLauLr6YqorllzJlND9VVMxev0ZgXMqQB+9LZqmERXncdn5spHWFRsW3l6umrgMGeX/j2nfrL1oQAAAFBBn1JFFSwj/wAAEtYuqloNODzUlUVt2B0G4WypQflIK5ZCKBs6d8GYll+vmva1hWGNkBWjiRVAT/erIOCyu/DD415Vo8f2/uCsvGI/ecu/wQAAADQBn3F0R/8AAB24ylkUK2Up2yqT39qfKZHNRu3zmKhSmQU+hi5kzUwWZXJlACZyFjflHV//AAAALgGfc2pH/wAAHammf1F6vb1ncGiHUsDY1mQxjbzS2yEgpVUJGKT+noQ76vTMzf4AAAByQZt4SahBbJlMCE///fEAAAMCLdEhyV6Cyvr51BnE7x2AKDaEDOSwvVtlFHepbLvuFUFaiO0qEt66ZNpYH4aag7g6bC9+XkAkT4EL2MvFUSOO0fpJE+Y0g3EkJY+MamnHQhsxZCujVM31p7TnS8xd2LAoAAAATEGflkUVLCP/AAAS3V9h4hAYQW5wCbXn/kE5EKdGN4RQa7+e2h+f/RMEE94R776jwATLGyZIMu6mPDBs0+xr01KQt1tXGJkO7gmN92EAAAA3AZ+1dEf/AAAduMpZFEK6kcOEk0UBKv5UAhT7EKXQ6waADaAFP+XwjDSJl9DFzCT3bl6c8kXyCwAAAEIBn7dqR/8AAB2ppwXgPdtp7pXSk4jYEORtR8lIVR3skVgzYi4ad9N4WjYAJo/vQMuIrChrFe86qPfyCMTN9Kvvd/gAAAB5QZu8SahBbJlMCEf//eEAAAMDYAprsCUT+E4JzGA0yFz5X3PITAG3BXjs34UOgYPPpfyj4O/6Sl87+ba9nCuawOEsODn1c5Zv87m2Od7EVRYYC170c5VRpNCZq99gr0T+3ml+ZTJlGTdULXDtA970nDclmItkxlTIoQAAAFdBn9pFFSwj/wAAElW2sgADhjYXGVafHUDTaOZHTz3z8E5JTFDaEb20AfZmwzW+pciwRO018MS4wGaIbDxppnqUn2cB9DHojmT5tu9Wo2QR0xZ5qPX3f4EAAAAtAZ/5dEf/AAAdCMpuROuCvHibWkWqI+PPQIhlxLSszYhsF8+4CXqpXV6e7+7BAAAAPgGf+2pH/wAAHOVChPzAgP8eq5QLfmW9c6e8aooUQ3ZYvoqy86Ha3WWBocYbUe4h48AJNpr163GxhHvTTHP3AAAAgEGb/kmoQWyZTBRMI//94QAAAwNgp5DhB1ABahFa0mTzCfNvX/FFv5ob4n5XNW1zn5EGzC6pqKf+IEVOSNPiIpPR4rjizePMHxzk3hORLKkB5ibhRxKjM9OVvDf2arGTSUIAfLTR4GCqnPJmd98GZ54+tvde2QHNV39fV0/GGol4AAAAPwGeHWpH/wAAHQbAaJ+WVL7ORHvy6aLJW5Q3XwvMwKc5yPLhyQlBYcBOmpXDC3GAC3iWnxUyT5DKMUcXz9Nv8QAAAGtBmgFJ4QpSZTAhH/3hAAADA2AJYWZ/ANLvmWxBf9o/HCxmC1hhzlB+Ob0uJsDS4aixL3uitxX4wGoZy5GtVup/8ASkvj1XUsiJMrQs5SLTBW1EnDQsKN98Vlt9j+tCaO7cyFGNP1bA48PgIAAAAD9Bnj9FNEx/AAAc6pjmzwDD1B7x5JvhGJbqequxtT8gbnT1Gp1B4I7lXK+mLGcJ0AE6uafAjEHsf4FiOs79ff4AAAA6AZ5Aakf/AAAdBsAdtDDhGbjST+KPWOPHUSvFZu/3jD+KB7Wb9lhIkrV/xJ8CKjbR4EAJqMxk63xH7wAAAIlBmkVJqEFomUwI//yEAAANPv9018rITXzT9AYutE3ml3PgM2LOmolqnOd478qc5P3UESOBaHEVnPZFcHFRv6swB+zQT3ik8FQgCznEKvUVBOelfkyyjevp/rXuiJw45BYn/bZ3E2AvkYwGuVIU0LnnYCtH8Y6pFM75algAzHpaHe2X+s8o430/gAAAAGVBnmNFESwj/wAAElW+S3ySfllZsm54UR9wdNlRk6J4u+97/SXwH1AARkzujjz9yRMRevr5l2rywe8iyHY8X2c0PD7VKlZr8LeemAjADc803JpxAy9mlwyuCpnoaIibKKIxnp6BwQAAAEYBnoJ0R/8AABz2xTfVBcW7/zw6L5gx9LyE/ksIgY4QAP173svd7S93Vh6BBXtrVFSui5wSvU4g+xgAff/ZdgxprHEuBBqhAAAAPAGehGpH/wAAHPj8G2HkyZR51V1o83WRuFABOGFGjut5NRUOQun9ACat17THiN/ZVA9eWydz29orameAcAAAAGtBmoZJqEFsmUwIT//98QAAAwIJxp/gAV5oafM+7QYOgaX7/fudhUFxJXJ2JSt3NwHnTVllBRDm44cMCKbqxAGsJIGVcubYQCWOij52StTmTuz/IavkeLPfYYf0L6t9Md3AkOo308izoQFMgQAAAHpBmqpJ4QpSZTAhH/3hAAADA0r4QV71QgB7aprBUe3dynCchBsdUeeZIxVXD4hkza/kO89+NXVzH94/LmEtWiJdGxhVzTHbci4Ow8GV5nMFD8c4zxw3dxLQMYv3iP3I6eoiHM9aUmd4SXfxj4dFY4ZWOq2DtA8s6dVMQAAAAFtBnshFNEwj/wAAEdW+Y1cajs0V2kRpEhIw9U0ZpaMo4tRZWDfCEA7VzDaCTB6F9S1hWT/MDCG4yXqrp01if03/Emxfb2VAVgFOpqH+sgAFzDEj7Il2AglwoUKhAAAAOgGe53RH/wAAG/TioCgTQWNWzPiw9pof25KF5ALt0Syd+MkpYL6QCigjWwYchcJ8QCPOGK5IiuukQBEAAABHAZ7pakf/AAAcPlF+3NlKPCQA4y4FhmPIksf/0Fxrt8+x89LYnfBxQV7REhgpkneq/ltzpyrYF48My55+yfoYj82HWMrTfg4AAAB5QZruSahBaJlMCE///fEAAAMCDdE1l+s4QAWB2sIzHnOfWMwmScyce1LnUDT0kd4XdGZJUdeGpjD24kEH4mRK/qGz/9CfmiMyDFQEYo+9cvIS2G61F278nEE5Qwl5QPiuG10Ivhq/iQZl1uOP1rLS5BKAJX8N6fyo5QAAAGxBnwxFESwj/wAAEdXgd8FB0Q7CBKgTatxXPb7iwc0lyTAARkzEJ/hUqY0dIPGa6iGzgMtG4PKW4xlNFyKr1qcNGJJkt2ALqCmpvTq3DSGfLE6sRxZaQ5Zs8PROMdlSITw1vcdCrAsrvVOxXmEAAABEAZ8rdEf/AAAcRnNL54L9fUONqzEZ6OroBdVguFPexghkhmsfyFDPGtD54X3LR9srTwAlfO5wv8iqIcpWL9gDJ/fj1gEAAAA6AZ8takf/AAAcSO02vSo2EqreWbRRyuiJGDuD919+P/4FZ+txjy1992QCjZBC3lq2YfHMlAysy7IG+QAAAJhBmzJJqEFsmUwIR//94QAAAwM2KaHveAKzQsTnXMvPvqnIp/+nPe90e6I54R3rmzHRgMSwSubJDIUqmBIglzJ0rdlNUIidRWYxKLgJdA53a1ANNuiEUk9oRQvQkq4BWBmCA8+ydmahoKrOArN+lB7EImeCMYZc9upQ6Pu7zION7YwLgTOZLr61wLF3PljG9tEDFOzyFgtbwAAAAFhBn1BFFSwj/wAAEV029FACwNOuuUrGiO2D2VITLQ2HwO62DhTAgQTsc7bDUBsrR40dL/BG+wVmD43P+B+ra+Nr2PL3F/VUTq9cG3wzX51YNW9nvTRrs4eBAAAATAGfb3RH/wAAG5o3DueU0lii7wGOyyiCsJ2cBb8wQ9Q8UEuseQlKQhZYZ9PACaf0s8hOTpjhddRLUfdUmJgnJhEFuwjizscgx2Sch4EAAABEAZ9xakf/AAAbjA0UzPwiAXEdcW/lG1M1nh64TeIRPjJ92PW7ZiAQfKQJP+M3EDQAaS3GazEboAJugzhKubmyBWir+aEAAAB9QZt2SahBbJlMCP/8hAAADJ+UJ8tEbr9Db53HkCA64ALg3hZkuk5ex42EyTeYZoQ8cRbXuCdR2vYTeNyt/Vwf+vgqVDkFk2B7pZJw4Qiuj0PWI9it5pBeUvcP23OgJjl9z2OfAYiQiu8AuoqxL8nZGu5Umx/1ZKiwlpJm1x8AAAB3QZ+URRUsI/8AABFiPz6o6R8QgAV69byahOTXBFY0+AJShCaA0zAw7ojTLE9yXJUKIvdT0HXYUXi5N6GeLL/8HC0+kMVaSG08lP+yv6A+io1jOV5BNB89TLkSlzpptZJIgScqCtjO3mvcmAuFkMMAEIRTSp2+PmgAAABOAZ+zdEf/AAAbqKLiiOHRvVOxYLrlCBmNoInhOWZG2K7isUN0fX0SP/f4/lVEpfG9/xsxEB7ka2rZa52xJzugJs4NQcAEmQTZ+znFo2wWAAAAVwGftWpH/wAAG59Lk57qLACu2Zp7DRNVuqaWlsOZY9sXddlmXxGDvioQrtujFog0SvAeqIL/CXoxSHoJdga6qL69KPkz8/0EkQiO/Sk0OmLzCPfyNj6bUQAAIYttb292AAAAbG12aGQAAAAAAAAAAAAAAAAAAAPoAAAy3AABAAABAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAgtXRyYWsAAABcdGtoZAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAy3AAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAEAAAAACWAAAAZAAAAAAACRlZHRzAAAAHGVsc3QAAAAAAAAAAQAAMtwAAAIAAAEAAAAAIC1tZGlhAAAAIG1kaGQAAAAAAAAAAAAAAAAAADIAAAKLAFXEAAAAAAAtaGRscgAAAAAAAAAAdmlkZQAAAAAAAAAAAAAAAFZpZGVvSGFuZGxlcgAAAB/YbWluZgAAABR2bWhkAAAAAQAAAAAAAAAAAAAAJGRpbmYAAAAcZHJlZgAAAAAAAAABAAAADHVybCAAAAABAAAfmHN0YmwAAACcc3RzZAAAAAAAAAABAAAAjGF2YzEAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAACWAGQAEgAAABIAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY//8AAAA2YXZjQwFkAB//4QAZZ2QAH6zZQJgz5eEAAAMAAQAAAwBkDxgxlgEABmjr48siwP34+AAAAAAYc3R0cwAAAAAAAAABAAACiwAAAQAAAAAcc3RzcwAAAAAAAAADAAAAAQAAAPsAAAH1AAAUUGN0dHMAAAAAAAACiAAAAAEAAAIAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAIAAAIAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAQAAAAAAgAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAAAwAAAAABAAABAAAAAAEAAAIAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAADAAAAAAEAAAEAAAAAAQAABAAAAAACAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAAAgAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAABxzdHNjAAAAAAAAAAEAAAABAAACiwAAAAEAAApAc3RzegAAAAAAAAAAAAACiwAABMUAAACjAAAALQAAADQAAAAfAAAAWwAAADcAAAAqAAAALgAAAGwAAAA3AAAAJAAAAB8AAABbAAAAOAAAACAAAAAyAAAATwAAACoAAAAjAAAAIAAAAIIAAAA0AAAAHwAAACEAAACKAAAAKAAAACcAAAAeAAAAQwAAACYAAAAmAAAAHwAAAGsAAAA0AAAAJwAAACQAAABtAAAAJgAAABcAAAAhAAAAOAAAADAAAAAvAAAAJAAAADkAAAA5AAAAMQAAACgAAAA/AAAAPAAAADIAAAAoAAAAJAAAADgAAAAhAAAAIgAAACsAAAAdAAAAEwAAABcAAAA1AAAAJwAAAB4AAAAnAAAAHwAAACYAAAAXAAAAFwAAACIAAAAxAAAAGAAAADkAAAAeAAAAMwAAAB0AAAAlAAAAKAAAADQAAAAhAAAAKgAAAFEAAAA3AAAAIgAAACQAAABUAAAANwAAACQAAAAsAAAAJQAAACQAAAAeAAAAGQAAABsAAAAdAAAAFwAAABcAAAAsAAAAHQAAABcAAAAXAAAAKQAAAB0AAAAXAAAAFwAAACMAAAAdAAAAFwAAABcAAABDAAAAIQAAABcAAAAdAAAALgAAACYAAAAeAAAAIwAAAEMAAAAnAAAAIQAAACMAAAAsAAAAJQAAABcAAAAXAAAAGwAAABwAAAAXAAAAFwAAABsAAAAbAAAAFwAAABcAAAAfAAAAGwAAABcAAAAXAAAAGwAAABsAAAAXAAAAFwAAABoAAAAbAAAAFwAAABcAAABGAAAAIgAAABcAAAAjAAAAbAAAADIAAAAjAAAALgAAAC4AAAAjAAAAJQAAABUAAAAbAAAAGgAAABQAAAAVAAAAMgAAABoAAAAUAAAAFQAAAEQAAAAbAAAAFQAAABYAAAAhAAAAMAAAAB0AAAAoAAAALwAAAD4AAAAfAAAAJAAAADEAAAAvAAAAMQAAAB4AAAAwAAAAIwAAADAAAAAtAAAANwAAACIAAAAdAAAAFwAAACIAAAAbAAAAGAAAABcAAAAbAAAAGwAAABYAAAAbAAAAiQAAADkAAAAyAAAAGgAAADwAAAAbAAAAFwAAABcAAAAiAAAAGgAAABgAAAAXAAAARQAAAC0AAAAWAAAAIAAAACEAAAAlAAAAIAAAAB4AAAAjAAAAMgAAAC4AAAArAAAAIwAAADIAAAAeAAAAIAAAACYAAAAaAAAAHgAAABcAAAAcAAAAGgAAABcAAAAXAAAAWQAAADQAAAAWAAAAIgAAAEEAAAA1AAAAMAAAAB8AAAA+AAAAMQAAABsAAAAdAAAALgAAABoAAAAXAAAAFwAAABoAAAGhAAAAgAAAADkAAAAsAAAAJgAAADsAAAAjAAAAGQAAABoAAAAbAAAAGwAAABUAAAAWAAAAGgAAABcAAAAUAAAAFQAAAHgAAAAmAAAAJAAAADEAAAA+AAAALAAAACMAAAAxAAAAGgAAABsAAAAWAAAAFgAAAEMAAAAkAAAAFgAAACEAAAAqAAAAOAAAACEAAAAuAAAAIgAAAC4AAAAcAAAAHgAAACUAAAAaAAAAFgAAABcAAABgAAAAMAAAACUAAAAkAAAAJQAAAB8AAAAbAAAAJgAAADEAAAAjAAAAFgAAABkAAAAyAAAAJgAAABwAAAAvAAAAKgAAAB4AAAASAAAAGAAAAEIAAAAgAAAAGAAAABoAAABfAAAAOgAAAC4AAAAXAAAAIAAAABkAAAAUAAAAEwAAAD0AAAAuAAAAHgAAACAAAAApAAAAHAAAABYAAAASAAAASgAAADYAAAAcAAAALwAAAFgAAAAnAAAAKgAAABgAAABAAAAANQAAACEAAAAwAAAAMgAAACMAAAAsAAAAFwAAAEcAAAAcAAAAFwAAABcAAABXAAAAJQAAAC8AAAAYAAAAMwAAACYAAAAfAAAAIgAAAFkAAAArAAAAIAAAABcAAABGAAAARwAAACsAAAAuAAAATAAAACMAAAAeAAAAIAAAAF8AAAAmAAAANAAAABcAAABLAAAALgAAABsAAAApAAAAbgAAACMAAAAqAAAAGwAAAFIAAAAlAAAALAAAABYAAABPAAAAIQAAACIAAAASAAAAMwAAACEAAAAuAAAAGwAAAEEAAAAzAAAAKQAAABsAAAAzAAAAJAAAACkAAAAqAAAARAAAACMAAAAlAAAAHAAAAEYAAAAqAAAAKwAAAC0AAABOAAAAOwAAACgAAAAvAAAAUgAAACoAAAAaAAAAKwAAAEkAAAA1AAAAIwAAADcAAABQAAAAPgAAACMAAAA/AAAAigAAAFoAAAAqAAAAQgAAAG4AAAA/AAAAOwAAAEIAAABUAAAAPgAAAGAAAAA4AAAARwAAACwAAAApAAAAKgAAAJYAAAA5AAAANQAAAC0AAABlAAAAQAAAAEEAAABxAAAASgAAAE0AAABIAAAAUAAAAFgAAABFAAAANAAAAE0AAABSAAAANgAAADAAAABNAAAARAAAAC4AAAAtAAAARQAAADsAAAA3AAAAJAAAAGUAAAAmAAAAIwAAACoAAAA3AAAAIwAAABcAAAAeAAAARwAAADUAAAAlAAAAIgAAAGMAAAA2AAAAKQAAAD4AAABYAAAALQAAABwAAAAsAAAARQAAAC8AAAAwAAAAGAAAAEIAAAAhAAABtwAAAFAAAAA6AAAAJAAAACoAAABVAAAAJgAAACMAAAAYAAAAXQAAACMAAAAgAAAAGwAAAD8AAAAgAAAALAAAACUAAABJAAAAOgAAACsAAAAxAAAAUwAAAEcAAAAiAAAAMQAAAEAAAAA1AAAAJQAAADEAAABGAAAANQAAACoAAAA0AAAATgAAADMAAAAZAAAAIQAAAFAAAAAwAAAAIAAAACwAAABVAAAAQwAAAC4AAAAzAAAATAAAAEQAAAA6AAAAHQAAAGIAAAAnAAAALQAAAB4AAABAAAAALAAAACsAAAAYAAAASQAAAEcAAAAmAAAAIQAAAEQAAAA4AAAAIwAAACMAAABDAAAAJwAAACsAAAAxAAAAQwAAAEwAAAAtAAAAKAAAAF8AAAA4AAAAQgAAADIAAABqAAAALQAAADoAAAAvAAAAXwAAAEwAAAA4AAAANwAAAIMAAABMAAAAQAAAAD8AAABKAAAAZAAAACMAAABCAAAAdAAAAEgAAAA2AAAAOgAAAGEAAAA3AAAAPQAAADcAAABgAAAAUwAAAEEAAABCAAAAbQAAAEoAAAA1AAAAMAAAAH0AAABsAAAANwAAADsAAABoAAAAVAAAADgAAAAyAAAAdgAAAFAAAAA7AAAARgAAAH0AAABbAAAAMQAAAEIAAACEAAAAQwAAAG8AAABDAAAAPgAAAI0AAABpAAAASgAAAEAAAABvAAAAfgAAAF8AAAA+AAAASwAAAH0AAABwAAAASAAAAD4AAACcAAAAXAAAAFAAAABIAAAAgQAAAHsAAABSAAAAWwAAABRzdGNvAAAAAAAAAAEAAAAwAAAAYnVkdGEAAABabWV0YQAAAAAAAAAhaGRscgAAAAAAAAAAbWRpcmFwcGwAAAAAAAAAAAAAAAAtaWxzdAAAACWpdG9vAAAAHWRhdGEAAAABAAAAAExhdmY1OC41MS4xMDE=\" type=\"video/mp4\" />\n",
       "                 </video>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Animate learned policy\n",
    "save_dir='./videos/pytorch/6_4/'\n",
    "env = make_env(ENV_NAME)\n",
    "generate_animation(env, agent, save_dir=save_dir)\n",
    "[filepath] = glob.glob(os.path.join(save_dir, '*.mp4'))\n",
    "display_animation(filepath)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary\n",
    "\n",
    "In this notebook we saw how to train a DQN agent with experience replay and target networks using variant  **Double DQN (DDQN)**. We used Replay Buffer. You could try following things to get more familiarity:\n",
    "\n",
    "* Implement DDQN in TensorFlow\n",
    "* Create DDQN with Prioritized Replay in PyTorch\n",
    "* Create DDQN with Prioritized Replay in TensorFlow\n",
    "* Make the notebooks more modular where you could choose the agent (DQN vs DDQN) as well as choose replay buffer options (Experience Replay vs Prioritized Experience Replay). You could build this modular notebook both in PyTorch and TensorFlow\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
